Difference Betwixt Treeset, Linkedhashset In Addition To 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 topographic point are lot of deviation betwixt them; which is of import to understand, therefore that you lot tin post away select most appropriate Set implementation based upon your requirement. By the way deviation betwixt TreeSet together with HashSet or LinkedHashSet is besides i of the popular Java Collection interview question, non equally pop equally Hashtable vs HashMap or ArrayList vs Vector but nevertheless appears inwards diverse Java interviews. In this article nosotros volition come across difference betwixt HashSet, TreeSet together with LinkedHashSet on diverse points e.g. Ordering of elements, performance, allowing nil etc together with and therefore nosotros volition come across When to usage 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 lodge together with HashSet is simply full general role collection for storing object. HashSet is implemented using HashMap inwards Java land TreeSet is implemented using TreeMap.  TreeSet is a SortedSet implementation which allows it to proceed elements inwards the sorted lodge defined past times either Comparable or Comparator interface. Comparable is used for natural lodge sorting together with Comparator for custom lodge sorting of objects, which tin post away move provided land creating instance of TreeSet. Anyway before seeing deviation betwixt TreeSet, LinkedHashSet together with HashSet, let's come across to a greater extent than or less similarities betwixt them:

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

2) Thread security : HashSet, TreeSet together with LinkedHashSet are non thread-safe, if you usage them inwards multi-threading environs where at to the lowest degree i Thread  modifies Set you lot ask 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 afterwards its creation past times whatever way other than Iterators remove() method, it volition throw ConcurrentModificationException amongst best of effort. read to a greater extent than about fail-fast vs fail-safe Iterator here

Now let’s come across difference betwixt HashSet, LinkedHashSet together with TreeSet inwards Java :

Performance together with Speed : First deviation betwixt them comes inwards damage of  speed.  HashSet is fastest, LinkedHashSet is minute on performance or most similar to HashSet but TreeSet is fleck 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 together with contains, land HashSet together with LinkedHashSet offering constant fourth dimension performance e.g. O(1) for add, contains together with take given hash role uniformly distribute elements inwards bucket.

Ordering : HashSet does non keep whatever lodge land LinkedHashSet maintains insertion lodge of elements much similar List interface together with TreeSet maintains sorting lodge or elements.

Internal Implementation : HashSet is backed past times an HashMap instance, LinkedHashSet is implemented using HashSet together with LinkedList land TreeSet is backed upward 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 land comparing amongst 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 move consistent to equals inwards Java. failing to practise therefore interruption full general contact of Set interface i.e. it tin post away permit duplicates.

TreeSet vs HashSet vs LinkedHashSet - Example

Let’s compare all these Set implementation on to a greater extent than or less points past times writing Java program. In this instance nosotros are demonstrating deviation inwards ordering, fourth dimension taking land inserting 1M records amidst TreeSet, HashSet together with LinkedHashSet inwards Java. This volition assistance to solidify to a greater extent than or less points which discussed inwards before department together with assistance to create upward one's heed when to usage 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 programme to demonstrate deviation 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 lodge or elements – LinkedHashSet storeds elements equally insertion
        System.err.println("Order of chemical ingredient inwards LinkedHashSet :" + fruitMarket);

        //should move sorted lodge – TreeSet stores chemical ingredient inwards sorted lodge
        System.out.println("Order of objects inwards TreeSet :" + fruitBuzz); 

     

        //Performance assay out 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 ingredient 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 usage HashSet, TreeSet together with LinkedHashSet inwards Java

Since all 3 implements Set interface they tin post away be used for mutual Set operations similar non allowing duplicates but since HashSet, TreeSet together with LinkedHashSet has at that topographic point exceptional characteristic which makes them appropriate inwards sure enough scenario. Because of sorting lodge provided past times TreeSet, usage TreeSet when you lot ask a collection where elements are sorted without duplicates. HashSet are rather full general role Set implementation, Use it equally default Set implementation if you lot ask a fast, duplicate costless collection. LinkedHashSet is extension of HashSet together with its to a greater extent than suitable where you lot ask to keep insertion order of elements, similar to List without compromising performance for costly TreeSet. Another usage of LinkedHashSet is for creating copies of existing Set, Since LinkedHashSet preservers insertion order, it returns Set which contains same elements inwards same lodge similar exact copy. In short,  although all 3 are Set interface implementation they offering distinctive feature, HashSet is a full general role Set land LinkedHashSet provides insertion lodge guarantee together with TreeSet is a SortedSet which stores elements inwards sorted lodge 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 post away move used to re-create objects from i Set to to a greater extent than or less 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 programme to copy object from i HashSet to to a greater extent than or less other using LinkedHashSet.
 * LinkedHashSet preserves lodge of chemical ingredient land 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 therefore that you lot tin post away supersede 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 deviation betwixt TreeSet, LinkedHashSet together with HashSet which is worth remembering than delight add together equally comment.

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

4 ways to loop Map inwards Java amongst 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

Sumber https://javarevisited.blogspot.com/