Difference Betwixt Treeset, Linkedhashset Together With Hashset Inwards Coffee Amongst Example

TreeSet, LinkedHashSet together with HashSet all are implementation of Set interface together with past times virtue of that, they follows contract of Set interface i.e. they practise non allow duplicate elements. Despite beingness from same type hierarchy,  at that spot are lot of divergence betwixt them; which is of import to understand, thus that you lot tin select most appropriate Set implementation based upon your requirement. By the way divergence betwixt TreeSet together with HashSet or LinkedHashSet is besides i of the popular Java Collection interview question, non every bit pop every bit Hashtable vs HashMap or ArrayList vs Vector but all the same appears inwards diverse Java interviews. In this article nosotros volition run into difference betwixt HashSet, TreeSet together with LinkedHashSet on diverse points e.g. Ordering of elements, performance, allowing nil etc together with and then nosotros volition run into When to exercise TreeSet or LinkedHashSet or simply HashSet inwards Java.

Difference betwixt TreeSet, LinkedHashSet together with HashSet inwards Java

TreeSet, LinkedHashSet together with HashSet inwards Java are 3 Set implementation inwards collection framework together with similar many others they are besides used to shop objects. Main characteristic of TreeSet is sorting,  LinkedHashSet is insertion guild together with HashSet is only full general role collection for storing object. HashSet is implemented using HashMap inwards Java spell TreeSet is implemented using TreeMap.  TreeSet is a SortedSet implementation which allows it to cash inwards one's chips on elements inwards the sorted guild defined past times either Comparable or Comparator interface. Comparable is used for natural guild sorting together with Comparator for custom guild sorting of objects, which tin hold upwards provided spell creating instance of TreeSet. Anyway before seeing divergence betwixt TreeSet, LinkedHashSet together with HashSet, let's run into about similarities betwixt them:

1) Duplicates : All 3 implements Set interface way they are non allowed to shop duplicates.

2) Thread security : HashSet, TreeSet together with LinkedHashSet are non thread-safe, if you exercise them inwards multi-threading environs where at to the lowest degree i Thread  modifies Set you lot bespeak to externally synchronize them.

3) Fail-Fast Iterator : Iterator returned past times TreeSet, LinkedHashSet together with HashSet are fail-fast Iterator. i.e. If Iterator is modified later its creation past times whatever way other than Iterators remove() method, it volition throw ConcurrentModificationException alongside best of effort. read to a greater extent than about fail-fast vs fail-safe Iterator here

Now let’s run into difference betwixt HashSet, LinkedHashSet together with TreeSet inwards Java :

Performance together with Speed : First divergence betwixt them comes inwards damage of  speed.  HashSet is fastest, LinkedHashSet is minute on performance or nearly similar to HashSet but TreeSet is flake slower because of sorting performance it needs to perform on each insertion. TreeSet provides guaranteed O(log(n)) fourth dimension for mutual operations similar add, take away together with contains, spell HashSet together with LinkedHashSet offering constant fourth dimension performance e.g. O(1) for add, contains together with take away given hash business office uniformly distribute elements inwards bucket.

Ordering : HashSet does non hold whatever guild spell LinkedHashSet maintains insertion guild of elements much similar List interface together with TreeSet maintains sorting guild or elements.

Internal Implementation : HashSet is backed past times an HashMap instance, LinkedHashSet is implemented using HashSet together with LinkedList spell TreeSet is backed upwards past times NavigableMap inwards Java together with past times default it uses TreeMap.

null : Both HashSet together with LinkedHashSet allows nil but TreeSet doesn't allow nil but TreeSet doesn't allow nil together with throw java.lang.NullPointerException when you lot volition insert nil into TreeSet. Since TreeSet uses compareTo() method of respective elements to compare them  which throws NullPointerException spell comparing alongside null, hither is an example:

TreeSet cities

Exception inwards thread "main" java.lang.NullPointerException

        at java.lang.String.compareTo(String.java:1167)

        at java.lang.String.compareTo(String.java:92)

        at java.util.TreeMap.put(TreeMap.java:545)

        at java.util.TreeSet.add(TreeSet.java:238)

Comparison : HashSet together with LinkedHashSet uses equals() method inwards Java for comparing but TreeSet uses compareTo() method for maintaining ordering. That's why compareTo() should hold upwards consistent to equals inwards Java. failing to practise thus intermission full general contact of Set interface i.e. it tin permit duplicates.

TreeSet vs HashSet vs LinkedHashSet - Example

Let’s compare all these Set implementation on about points past times writing Java program. In this instance nosotros are demonstrating divergence inwards ordering, fourth dimension taking spell inserting 1M records amid TreeSet, HashSet together with LinkedHashSet inwards Java. This volition assistance to solidify about points which discussed inwards before department together with assistance to create upwards one's take heed when to exercise HashSet, LinkedHashSet or TreeSet inwards Java.

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * Java plan to demonstrate divergence betwixt TreeSet, HashSet together with LinkedHashSet

 * inwards Java Collection.
 * @author
 */
public class SetComparision {
 
    public static void main(String args[]){            
        HashSet<String> fruitsStore = new HashSet<String>();
        LinkedHashSet<String> fruitMarket = new LinkedHashSet<String>();
        TreeSet<String> fruitBuzz = new TreeSet<String>();
     
        for(String fruit: Arrays.asList("mango", "apple", "banana")){
            fruitsStore.add(fruit);
            fruitMarket.add(fruit);
            fruitBuzz.add(fruit);
        }
       

        //no ordering inwards HashSet – elements stored inwards random order
        System.out.println("Ordering inwards HashSet :" + fruitsStore);

        //insertion guild or elements – LinkedHashSet storeds elements every bit insertion
        System.err.println("Order of chemical constituent inwards LinkedHashSet :" + fruitMarket);

        //should hold upwards sorted guild – TreeSet stores chemical constituent inwards sorted guild
        System.out.println("Order of objects inwards TreeSet :" + fruitBuzz); 

     

        //Performance try to insert 10M elements inwards HashSet, LinkedHashSet together with TreeSet
        Set<Integer> numbers = new HashSet<Integer>();
        long startTime = System.nanoTime();
        for(int i =0; i<10000000; i++){
            numbers.add(i);
        }

        long endTime = System.nanoTime();
        System.out.println("Total fourth dimension to insert 10M elements inwards HashSet inwards second : "

                            + (endTime - startTime));
     
     
        // LinkedHashSet performance Test – inserting 10M objects

        numbers = new LinkedHashSet<Integer>();
        startTime = System.nanoTime();
        for(int i =0; i<10000000; i++){
            numbers.add(i);
        }
        endTime = System.nanoTime();
        System.out.println("Total fourth dimension to insert 10M elements inwards LinkedHashSet inwards second : "

                            + (endTime - startTime));
       

        // TreeSet performance Test – inserting 10M objects
        numbers = new TreeSet<Integer>();
        startTime = System.nanoTime();
        for(int i =0; i<10000000; i++){
            numbers.add(i);
        }
        endTime = System.nanoTime();
        System.out.println("Total fourth dimension to insert 10M elements inwards TreeSet inwards second : "

                            + (endTime - startTime));
    }
}

Output
Ordering inwards HashSet :[banana, apple, mango]
Order of chemical constituent inwards LinkedHashSet :[mango, apple, banana]
Order of objects inwards TreeSet :[apple, banana, mango]
Total fourth dimension to insert 10M elements inwards HashSet inwards second : 3564570637
Total fourth dimension to insert 10M elements inwards LinkedHashSet inwards second : 3511277551
Total fourth dimension to insert 10M elements inwards TreeSet inwards second : 10968043705

When to exercise HashSet, TreeSet together with LinkedHashSet inwards Java

Since all 3 implements Set interface they tin be used for mutual Set operations similar non allowing duplicates but since HashSet, TreeSet together with LinkedHashSet has at that spot particular characteristic which makes them appropriate inwards certainly scenario. Because of sorting guild provided past times TreeSet, exercise TreeSet when you lot bespeak a collection where elements are sorted without duplicates. HashSet are rather full general role Set implementation, Use it every bit default Set implementation if you lot bespeak a fast, duplicate gratuitous collection. LinkedHashSet is extension of HashSet together with its to a greater extent than suitable where you lot bespeak to hold insertion order of elements, similar to List without compromising performance for costly TreeSet. Another exercise of LinkedHashSet is for creating copies of existing Set, Since LinkedHashSet preservers insertion order, it returns Set which contains same elements inwards same guild similar exact copy. In short,  although all 3 are Set interface implementation they offering distinctive feature, HashSet is a full general role Set spell LinkedHashSet provides insertion guild guarantee together with TreeSet is a SortedSet which stores elements inwards sorted guild specified past times Comparator or Comparable inwards Java.

How to re-create object from i Set to other

Here is code instance of LinkedHashSet which demonstrate How LinkedHashSet tin hold upwards used to re-create objects from i Set to about other without losing order. You volition larn exact replica of root Set, inwards damage of contents together with order. Here static method copy(Set source) is written using Generics, This form of parameterized method provides type-safety together with assistance to avoid ClassCastException at runtime.

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * Java plan to copy object from i HashSet to about other using LinkedHashSet.
 * LinkedHashSet preserves guild of chemical constituent spell copying elements.
 *
 * @author Javin
 */
public class SetUtils{
   
    public static void main(String args[]) {
       
        HashSet<String> root = new HashSet<String>(Arrays.asList("Set, List, Map"));
        System.out.println("source : " + source);
        Set<String> re-create = SetUtils.copy(source);
        System.out.println("copy of HashSet using LinkedHashSet: " + copy);
    }
   
    /*
     * Static utility method to re-create Set inwards Java
     */
    public static <T> Set<T> copy(Set<T> source){
           return new LinkedHashSet<T>(source);
    }
}
Output:
root : [Set, List, Map]
re-create of HashSet using LinkedHashSet: [Set, List, Map]

Always code for interface than implementation thus that you lot tin supercede HashSet to LinkedHashSet or TreeSet when your requirement changes. That’s all on difference betwixt HashSet, LinkedHashSet together with TreeSet inwards Java.  If you lot know whatever other pregnant divergence betwixt TreeSet, LinkedHashSet together with HashSet which is worth remembering than delight add together every bit comment.

Further Learning
Java In-Depth: Become a Complete Java Engineer
How to sort ArrayList inwards descending guild inwards Java

4 ways to loop Map inwards Java alongside examples

How to convert List to Array inwards Java

How to create read exclusively or unmodifiable Collection inwards Java

How to convert Collection to coma separated String inwards Java

10 instance of Hashtable inwards Java - tutorial