> Java > LinkedHashSet Vs TreeSet

LinkedHashSet Vs TreeSet in Java

Last Updated: 22 January, 2023

LinkedHashSet and TreeSet both implement the Set interface in Java and are available in the java.util package.

There are many differences between the LinkedHashSet and TreeSet that are given below.

👉 LinkedHashSet

The LinkedHashSet class of the Java collections framework was introduced in the JDK 1.4 version and is available in the java.util package.

LinkedHashSet is the Hashtable and linked list implementation of the Set interface with preserved iteration order. The linked list defines the iteration order, which is the order in which elements are inserted into the set. Insertion order is not affected if an element is re-inserted into the set.

LinkedHashSet is a child class of HashSet, so it has all the functionalities of the HashSet class. The HashSet does not maintain the insertion order of elements, whereas the LinkedHashSet maintains the element insertion order. This one is the main difference between both.

Java LinkedHashSet Class Declaration

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable

Here, E defines the type of elements that the Set will contain.

Java LinkedHashSet important features:

The underlying data structure is a hash table + linked list. It uses the implementation of a doubly-linked list on the hash table.
LinkedHashSet only stores unique elements; no duplicates are allowed.
LinkedHashSet maintains insertion order using a doubly linked list.
LinkedHashSet also supported inserting a single null value.
No new methods are added in the LinkedHashSet class; all are extended from HashSet.
LinkedHashSet is not synchronized.
Uses a hashing technique to store elements at the specified index based on the hashcode.
LinkedHashSet is the best choice to develop cache-based applications where duplicates are not allowed and insertion orders must be preserved.

👉 TreeSet

The TreeSet class of the Java collections framework was introduced in the JDK 1.2 version and is available in the java.util package.

A TreeSet is a sorted collection of objects. A TreeSet is the implementation of the SortedSet interface in Java that uses a tree for storage. The ordering of the elements is maintained by a set using their natural (ascending) order.

TreeSet provides fast access and retrieval operations, which makes TreeSet an excellent choice when storing large amounts of sorted information that must be found quickly.

Java TreeSet Class Declaration

public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable

Here, E defines the type of elements that the Set will contain.

Java TreeSet important features:

The underlying data structure of the TreeSet is the balanced tree.
TreeSet stores elements in a default ascending order.
TreeSet class internally uses a TreeMap to store elements.
TreeSet only contains unique elements; it does not accept duplicates.
TreeSet does not accept duplicate or null elements.
TreeSet is by default a non-synchronized class.
Access and retrieval times are quite fast, which makes TreeSet an excellent choice when storing large amounts of sorted information.

👉 LinkedHashSet and TreeSet have the following differences:

LinkedHashSet and TreeSet have many differences. Let's understand with the help of the given table.

LinkedHashSet	TreeSet
The underlying data structure is a hash table + linked list (doubly linked list).	The underlying data structure of the TreeSet is the Balanced Tree.
Preserve the iteration order (ordered set).	Store the elements in a sorted order (default, in ascending order).
Introduced in the JDK 1.4 version.	Introduced in the JDK 1.2 version.
Allows to insert null value.	Does not allow to insert null.

👉 Example of LinkedHashSet and TreeSet in Java

Example 1: A sample Java program of LinkedHashSet

  
  import java.util.LinkedHashSet;
  public class LinkedHasSetExample {
    public static void main(String[] args) {
      // Creating a LinkedHashSet
      LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<Integer>();
        
      // Adding elements into the LinkedHashSet
      linkedHashSet.add(800);
      linkedHashSet.add(500);
      linkedHashSet.add(null); // Adding null as an element
      linkedHashSet.add(200);
      linkedHashSet.add(500); // Adding duplicate element will be ignored
      
      // Printing LinkedHashSet elements
      System.out.println("LinkedHashSet elements: " + linkedHashSet);
    }
  }

Output

LinkedHashSet elements: [800, 500, null, 200]

Example 2: A sample Java program of TreeSet

  
  import java.util.TreeSet;
  public class TreeSetExample1 {
    public static void main(String[] args) {
      
      // Creating a TreeSet
      TreeSet<Integer> tree = new TreeSet<Integer>();
      
      // Adding elements in TreeSet
      tree.add(40);
      tree.add(20);
      tree.add(10);
      tree.add(50);
      tree.add(30);
      tree.add(30);
      
      // Printing TreeSet 
      System.out.println(tree);
    }
  }

Output

[10, 20, 30, 40, 50]

That's all guys, hope this Java article is helpful for you.

Happy Learning... 😀

Please share this article on social media to help others.

If you have any query or suggestion regarding this artical please share with us
feedback@javabytechie.com