Sets – HashSet, LinkedHashSet, and TreeSet

Java provides a mechanism in Collection framework that doesn’t store duplicate values. This Set Interface is present in the java.util package. It is an unordered collection of different objects in which we can store only the unique values.

Set interface directly extends Collection Interface. Set interface does not permit the insertion of duplicate elements. HashSet, LinkedHashSet and TreeSet are some of the classes that extend Set interface. Some of the methods that are present in Set interface are:

• add(Object element) – It adds the object passed as parameter if the object is not already present in the collection.
• clear() – It deletes all the elements present in the collection and makes it empty.
• contains(Object element) – It returns true, if the object passed as parameter is present in the collection. Otherwise, it returns false.
• size() – It returns an integer value denoting the number of elements present in the collection.

In this section we will be discussing about the different kinds of Sets that we can use in Java Language. This will help to perform various kinds of manipulations on the Data.

1. Hash Set
2. Linked Hash Set
3. Tree Set

Let’s deep dive, in order to understand more about the above mentioned Set types.

Hash Set

HashSet is a class which implements the Set interface that in turn provides a HashTable for the storage of elements. It stores the unique elements only. The order in which the elements are iterated is not guaranteed to show in the order it was inserted in the set.

Some important points to note about the HashSet are:

• Does not allow duplicate values
• It allows Null elements
• Stores the value by using a concept called as Hashing
• It is non synchronized
• It is best suited for the search operations
• It does not maintain the insertion order

Syntax-

HashSet<String> set=new HashSet();  

How HashSet Works?

Whenever we instantiate an object of HashSet in Java, it in turn instantiates an object of HashMap which stores all the objects we inserted into the HashSet as its key. The value of all the keys in the HashMap is set as a constant called “PRESENT” which is predefined in the HashSet implementation class. And this is the reason that HashSet only stores unique objects because its internal implementation i.e. HashMap cannot have duplicate keys. This makes it clear that whenever an add() method is called on a HashSet, it internally calls a put() method for a HashMap.

Example-

import java.util.HashSet;
import java.util.Iterator;

public class Test {

	public static void main(String args[]) {
		// Creating HashSet and adding elements
		HashSet<String> setVal = new HashSet<String>(); //Declaring a HashSet
		setVal.add("Welcome");
		setVal.add("To");
		setVal.add("QATechHub");

		Iterator<String> i = setVal.iterator();   //Iterating the whole HashSet
		while (i.hasNext()) {
			System.out.println(i.next());
		}
	}
}

Output-

QATechHub
Welcome
To

In the above example, we have used the iterator for traversing through all the elements that are stored in the HashSet.

Following is the list of Methods provided for HashSet Class:

LinkedHashSet

‘Linked’, as the name suggests, it uses the concept of doubly linked list. It is a HashSet which maintains a doubly linked list. It implements the Set interface and inherits the HashSet Class

Some important points to note about the LinkedHashSet are:

• Does not allow duplicate values
• It allows Null elements
• It is non synchronized
• It maintains the insertion order
• In this, the elements could be added or removed from both ends

Syntax-

LinkedHashSet<String> setVal = new LinkedHashSet<String>();

Let’s see a Basic Example, of how we can add & iterate different elements in the LinkedHashSet.

import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test {

	public static void main(String args[]) {
		// Creating LinkedHashSet and adding elements
		LinkedHashSet<String> setVal = new LinkedHashSet<String>(); // Declaring a LinkedHashSet
		setVal.add("Welcome");
		setVal.add("To");
		setVal.add("QATechHub");

		Iterator<String> i = setVal.iterator(); // Iterating the whole LinkedHashSet
		while (i.hasNext()) {
			System.out.println(i.next());
		}
	}
}

Output-

Welcome
To
QATechHub

Following is the list of Methods provided for LinkedHashSet Class:

TreeSet

Tree set Class implements the Set interface and inherits the Abstract class and implements the NavigableSet interface. It uses a tree for the storage of the elements. All the elements in the TreeSet are stored in an ascending order.

Some important points to note about the TreeSet are:

• Elements are by default sorted and stored in ascending order
• It is non Synchronized
• Does not allow to store the null elements
• It contains only the unique elements
• It does not preserve the insertion order of the elements

Syntax-

TreeSet<String> setVal = new TreeSet<String>();

Example

import java.util.Iterator;
import java.util.TreeSet;

public class Test {

	public static void main(String args[]) {
		// Creating HashSet and adding elements
		TreeSet<String> setVal = new TreeSet<String>(); // Declaring a TreeSet
		setVal.add("Welcome");
		setVal.add("To");
		setVal.add("QATechHub");

		Iterator<String> i = setVal.iterator(); // Iterating the whole HashSet
		while (i.hasNext()) {
			System.out.println(i.next());
		}
	}
}

Output-

QATechHub
To
Welcome

Following is the list of Methods provided for TreeSet Class:

Difference between HashSet, LinkedHashSet, And TreeSet