HashSet Vs LinkedHashSet Performance Test

Question

From here I red that HashSet has slightly better performance than LinkedHashSet. But when tried to execute a sample program, I getting a different result.

     /*
     * HashSet not order not sorted
     */
    long hsTime = System.nanoTime();
    Set<String> hs = new HashSet<String>();
      // add elements to the hash set
    hs.add("B");
    hs.add("A");
    hs.add("D");
    hs.add("E");
    hs.add("C");
    hs.add("F");
    System.out.println("HashSet ---->"+hs); // HashSet ---->[D, E, F, A, B, C]
    System.out.println("Execution time HashSet ---->"+(System.nanoTime() - hsTime)); // Execution time HashSet ---->275764

    /*
     * LinkedHashSet will maintain its insertion order but no sorting
     */
    long lhsTime  = System.nanoTime();
    Set<String> lhs = new LinkedHashSet<String>();
      // add elements to the hash set
    lhs.add("B");
    lhs.add("A");
    lhs.add("D");
    lhs.add("E");
    lhs.add("C");
    lhs.add("F");
    System.out.println("LinkedHashSet ---->"+lhs); //LinkedHashSet ---->[B, A, D, E, C, F]
    System.out.println("Execution time LinkedHashESet ---->"+(System.nanoTime() - lhsTime)); // Execution time LinkedHashESet ---->201181

Showing that LinkedHashSet having better performance. Can someone clarify which one having better performance.

Note: When I comment out these two lines :

System.out.println("HashSet ---->"+hs);
System.out.println("LinkedHashSet ---->"+lhs);

It is showing HashSet having better performance. Where the output is

Execution time HashSet ---->32304
Execution time LinkedHashESet ---->74414

Start reading here: http://stackoverflow.com/questions/504103/how-do-i-write-a-correct-micro-benchmark-in-java (and be prepared to continue reading for a while). (Side note: For sequential iteration over all elements, `LinkedHashSet` tends to be (noticably) faster than `HashSet`, whereas insertions/removals should be a tad slower - but don't believe everything that you read on the internet ;-)) — Marco13, Aug 03 '15 at 17:45
I think you were about to say `LinkedHashSet tends to be (noticably) faster than HashSet` right? — Suganthan Madhavan Pillai, Aug 03 '15 at 17:47
Sure, fixed (although the same should apply to `LinkedHashMap` and `HashMap`, referring to the entry set) — Marco13, Aug 03 '15 at 17:49

score 1 · Accepted Answer · answered Aug 03 '15 at 17:33

1

I suspect it is due to the warmup time taken by the JVM when doing the first loop when outputing the HashSet in the following statement:

System.out.println("HashSet ---->"+hs);

which is equivalent to something like

Iterator<E> i = iterator();
if (! i.hasNext())
    return "[]";

StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
    E e = i.next();
    sb.append(e == this ? "(this Collection)" : e);
    if (! i.hasNext())
    return sb.append(']').toString();
    sb.append(", ");
}
System.out.println("HashSet ---->" + sb.toString());

answered Aug 03 '15 at 17:33

M A

71,713
13
134
174

I didn't got your example in detail, but you are right about the term `warmup`. – Suganthan Madhavan Pillai Aug 03 '15 at 17:39
@Suganthan I think if you flip the order, i.e. do the part of the `LinkedHashSet` before the `HashSet`, you would get the same result: the first is slower than the second. – M A Aug 03 '15 at 17:49
1

I did the same...and I experience a different result, which shows `HashSet` is faster that `LinkedHashSet`. Thanks – Suganthan Madhavan Pillai Aug 03 '15 at 17:51
1

@Suganthan the result of doing that should tell you that your measurement is unreliable, not that one is faster than the other. – Louis Wasserman Aug 03 '15 at 18:24

HashSet Vs LinkedHashSet Performance Test

1 Answers1