HashSet vs LinkedHashSet vs TreeSet In Java

All HashSet, LinkedHashSet, and TreeSet In Java have some similarities, Like:

• Can not contain duplicate items: All HashSet, LinkedHashSet, and TreeSet are implements Set interface. So they are not allowed to contains duplicates elements or objects.
• Not Thread Safe: All three are not synchronized and hence not Thread safe.
• Cloneable and Serializable: All three (HashSet, LinkedHashSet, TreeSet) are Cloneable and Serializable.
• fail-fast Iterator: All three will returne fail-fast Iterator. That is, ConcurrentModificationException will be thrown, if you try to modify the Iterator object after creation.

Set Hierarchy:

HashSet:

HashSet represents a group of unique elements and it does not maintains any order for it’s objects or elements. It extends AbstractSet and implements the Set interface. HashSet uses hash table for it’s internal storage.

Example

import java.util.*;  
public class Main {  
 
    public static void main(String args[]){  
          // Create HashSet
          HashSet subjects = new HashSet<>();
 
          // Add elements to HashSet
          subjects.add("Java");
          subjects.add("Angular");
          subjects.add("Spring");
          subjects.add("Oracle");
          subjects.add("MySQL");
 
          //Add duplicate elements to HashSet
          subjects.add("Java");
          subjects.add("Spring");
 
          //Add null values to HashSet
          subjects.add(null);
          subjects.add(null);
 
          //Print HashSet elements
          System.out.println(subjects);
 
    }  
}

Output

[null, Java, MySQL, Spring, Oracle, Angular]

LinkedHashSet:

LinkedHashSet extends HashSet class and implements Set interface. Like HashSet, it also represents a group of unique objects but it maintains insertion order for them.

Example

import java.util.*;  
public class Main {  
 
    public static void main(String args[]){  
          // Create LinkedHashSet
          LinkedHashSet subjects = new LinkedHashSet<>();
 
          // Add elements to HashSet
          subjects.add("Java");
          subjects.add("Angular");
          subjects.add("Spring");
          subjects.add("Oracle");
          subjects.add("MySQL");
 
          //Add duplicate elements to LinkedHashSet
          subjects.add("Java");
          subjects.add("Spring");
 
          //Add null values to LinkedHashSet
          subjects.add(null);
          subjects.add(null);
 
          //Print LinkedHashSet elements
          System.out.println(subjects);
 
    }  
}

Output

[Java, Angular, Spring, Oracle, MySQL, null]

TreeSet:

TreeSet extends AbstractSet and implements NavigableSet interface. Like HashSet and LinkedHashSet it also represents a group of unique elements but maintains ascending order for them.

Example

import java.util.*;  
public class Main {  
 
    public static void main(String args[]){  
          // Create TreeSet
          TreeSet subjects = new TreeSet<>();
 
          // Add elements to HashSet
          subjects.add("Java");
          subjects.add("Angular");
          subjects.add("Spring");
          subjects.add("Oracle");
          subjects.add("MySQL");
 
          //Add duplicate elements to TreeSet
          subjects.add("Java");
          subjects.add("Spring");
 
          //Print TreeSet elements
          System.out.println(subjects);
 
    }  
}

Output

[Angular, Java, MySQL, Oracle, Spring]

When to use HashSet, LinkedHashSet, and TreeSet:

• Use HashSet: When there is no need to keep any order in elements but group of unique objects is needed.
• Use LinkedHashSet: When group of unique elements is needed and insertion order of elements is also required.
• Use TreeSet: When group of unique items/elements/objects is needed and sorting of the elements is required according to some Comparator.

Difference between HashSet, LinkedHashSet, and TreeSet

import java.util.*;  
public class Main {  
 
    //Method to display order of objects in HashSet 
    private static void objectsOrderHashSet() 
    { 
        HashSet<String> hashSet = new HashSet<String>(); 
 
        // Add object in HashSet 
        for (String str : Arrays.asList("Java", "Spring", "Hibernate")) {
            hashSet.add(str); 
        } 
 
        System.out.println("Order of objects in HashSet :" + hashSet); 
    } 
 
    //Method to display order of objects in LinkedHashSet 
    private static void objectsOrderLinkedHashSet() 
    { 
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>(); 
 
        // Add object in LinkedHashSet 
        for (String str : Arrays.asList("Java", "Spring", "Hibernate")) {
            linkedHashSet.add(str); 
        } 
 
        System.out.println("Order of objects in LinkedHashSet :" + linkedHashSet);
    } 
 
    //Method to display order of objects in TreeSet
    private static void objectsOrderTreeSet() 
    { 
        TreeSet<String> treeSet = new TreeSet<String>(); 
 
        // Add object in TreeSet 
        for (String str : Arrays.asList("Java", "Spring", "Hibernate")) {
            treeSet.add(str); 
        } 
 
        System.out.println("Order of objects in TreeSet :" + treeSet);
    } 
 
    // Method to calculate insertion time of 2000 objects in HashSet 
    private static void insertionTimeHashSet() 
    { 
        HashSet<Integer> hashSet = new HashSet<>(); 
        long startTime = System.nanoTime(); 
        for (int i = 0; i < 2000; i++) { 
            hashSet.add(i); 
        } 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to insert 2000 objects in HashSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    // Method to calculate insertion time of 2000 objects in LinkedHashSet 
    private static void insertionTimeLinkedHashSet() 
    { 
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(); 
        long startTime = System.nanoTime(); 
        for (int i = 0; i < 2000; i++) { 
            linkedHashSet.add(i); 
        } 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to insert 2000 objects in LinkedHashSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    // Method to calculate insertion time of 2000 objects in TreeSet 
    private static void insertionTimeTreeSet() 
    { 
        TreeSet<Integer> treeSet = new TreeSet<>(); 
        long startTime = System.nanoTime(); 
        for (int i = 0; i < 2000; i++) { 
            treeSet.add(i); 
        } 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to insert 2000 objects in TreeSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    // Method to calculate deletion time of 2000 objects from HashSet 
    private static void deletionTimeHashSet() 
    { 
        HashSet<Integer> hashSet = new HashSet<>(); 
 
        for (int i = 0; i < 2000; i++) { 
            hashSet.add(i); 
        } 
 
        long startTime = System.nanoTime();
 
        for (int i = 0; i < 2000; i++) { 
            hashSet.remove(i); 
        }
 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to delete 2000 objects from HashSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    // Method to calculate deletion time of 2000 objects from LinkedHashSet 
    private static void deletionTimeLinkedHashSet() 
    { 
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(); 
 
        for (int i = 0; i < 2000; i++) { 
            linkedHashSet.add(i); 
        } 
 
        long startTime = System.nanoTime();
 
        for (int i = 0; i < 2000; i++) { 
            linkedHashSet.remove(i); 
        }
 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to delete 2000 objects from LinkedHashSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    // Method to calculate deletion time of 2000 objects from TreeSet 
    private static void deletionTimeTreeSet() 
    { 
        TreeSet<Integer> treeSet = new TreeSet<>(); 
 
        for (int i = 0; i < 2000; i++) { 
            treeSet.add(i); 
        } 
 
        long startTime = System.nanoTime();
 
        for (int i = 0; i < 2000; i++) { 
            treeSet.remove(i); 
        }
 
        long endTime = System.nanoTime(); 
        System.out.println("Time taken to delete 2000 objects from TreeSet (seconds): "); 
        System.out.println(endTime - startTime); 
    } 
 
    public static void main(String args[]) 
    { 
        objectsOrderHashSet(); 
        objectsOrderLinkedHashSet(); 
        objectsOrderTreeSet(); 
        insertionTimeHashSet();
        insertionTimeLinkedHashSet();
        insertionTimeTreeSet();
        deletionTimeHashSet();
        deletionTimeLinkedHashSet();
        deletionTimeTreeSet();
    }  
}

import java.util.*; public class Main { //Method to display order of objects in HashSet private static void objectsOrderHashSet() { HashSet<String> hashSet = new HashSet<String>(); // Add object in HashSet for (String str : Arrays.asList("Java", "Spring", "Hibernate")) { hashSet.add(str); } System.out.println("Order of objects in HashSet :" + hashSet); } //Method to display order of objects in LinkedHashSet private static void objectsOrderLinkedHashSet() { LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>(); // Add object in LinkedHashSet for (String str : Arrays.asList("Java", "Spring", "Hibernate")) { linkedHashSet.add(str); } System.out.println("Order of objects in LinkedHashSet :" + linkedHashSet); } //Method to display order of objects in TreeSet private static void objectsOrderTreeSet() { TreeSet<String> treeSet = new TreeSet<String>(); // Add object in TreeSet for (String str : Arrays.asList("Java", "Spring", "Hibernate")) { treeSet.add(str); } System.out.println("Order of objects in TreeSet :" + treeSet); } // Method to calculate insertion time of 2000 objects in HashSet private static void insertionTimeHashSet() { HashSet<Integer> hashSet = new HashSet<>(); long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { hashSet.add(i); } long endTime = System.nanoTime(); System.out.println("Time taken to insert 2000 objects in HashSet (seconds): "); System.out.println(endTime - startTime); } // Method to calculate insertion time of 2000 objects in LinkedHashSet private static void insertionTimeLinkedHashSet() { LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(); long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { linkedHashSet.add(i); } long endTime = System.nanoTime(); System.out.println("Time taken to insert 2000 objects in LinkedHashSet (seconds): "); System.out.println(endTime - startTime); } // Method to calculate insertion time of 2000 objects in TreeSet private static void insertionTimeTreeSet() { TreeSet<Integer> treeSet = new TreeSet<>(); long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { treeSet.add(i); } long endTime = System.nanoTime(); System.out.println("Time taken to insert 2000 objects in TreeSet (seconds): "); System.out.println(endTime - startTime); } // Method to calculate deletion time of 2000 objects from HashSet private static void deletionTimeHashSet() { HashSet<Integer> hashSet = new HashSet<>(); for (int i = 0; i < 2000; i++) { hashSet.add(i); } long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { hashSet.remove(i); } long endTime = System.nanoTime(); System.out.println("Time taken to delete 2000 objects from HashSet (seconds): "); System.out.println(endTime - startTime); } // Method to calculate deletion time of 2000 objects from LinkedHashSet private static void deletionTimeLinkedHashSet() { LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(); for (int i = 0; i < 2000; i++) { linkedHashSet.add(i); } long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { linkedHashSet.remove(i); } long endTime = System.nanoTime(); System.out.println("Time taken to delete 2000 objects from LinkedHashSet (seconds): "); System.out.println(endTime - startTime); } // Method to calculate deletion time of 2000 objects from TreeSet private static void deletionTimeTreeSet() { TreeSet<Integer> treeSet = new TreeSet<>(); for (int i = 0; i < 2000; i++) { treeSet.add(i); } long startTime = System.nanoTime(); for (int i = 0; i < 2000; i++) { treeSet.remove(i); } long endTime = System.nanoTime(); System.out.println("Time taken to delete 2000 objects from TreeSet (seconds): "); System.out.println(endTime - startTime); } public static void main(String args[]) { objectsOrderHashSet(); objectsOrderLinkedHashSet(); objectsOrderTreeSet(); insertionTimeHashSet(); insertionTimeLinkedHashSet(); insertionTimeTreeSet(); deletionTimeHashSet(); deletionTimeLinkedHashSet(); deletionTimeTreeSet(); } }