Java LinkedHashSet

In this tutorial, we will learn about the Java LinkedHashSet class and its methods with the help of examples.

The Java LinkedHashSet class in the Java collection framework provides the functionality of hash table and linked list data structures.

it implementsSet interface.

elements of LinkedHashSet are stored in a manner similar toHashSet'swithin the hash table.

However, the linked list hash set maintains a doubly linked list for all its elements internally. The linked list defines the order in which elements are inserted into the hash table.

Create a LinkedHashSet

To create a linked list hash set, we must first import the java.util.LinkedHashSet package.

After importing the package, you can create a linked list hash set in Java.

//It has8a capacity of and 0.75LinkedHashSet with
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Here, we create a linked list hash set named numbers.

Note, the statement new LinkedHashSet<>(8, 0.75). Here, the first parameter isCapacity, the second parameter isLoad factor.

• capacity - The capacity of this hash set is8. It means that it can store8elements.

• loadFactor- The load factor of this hash set is 0.6. This means that as long as our hash table is filled60%, the element will be moved to a new hash table, which is twice the size of the original hash table.

default capacity and load factor

A linked hash set can be created without defining its capacity and load factor. For example,

//LinkedHashSet with default capacity and load factor
LinkedHashSet<Integer> numbers1　= new LinkedHashSet<>();

By default,

• The capacity of the linked hash set will be16

• The load factor will be 0.75

Create LinkedHashSet from other collections

This is how we create a linked hash set containing all elements of other collections.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Create an arrayList of even numbers
　　　　　　　　ArrayList<Integer> evenNumbers = new ArrayList<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("ArrayList: ",　+　evenNumbers);
　　　　　　　　//Create LinkedHashSet from ArrayList
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
　　　　　　　　System.out.println("LinkedHashSet:　"　+　numbers);
　　　　}
}

Output result

ArrayList: [2,　4]
LinkedHashSet:　[2,　4]

LinkedHashSet methods

The LinkedHashSet class provides various methods for performing operations on the linked hash set.

Insert the element into the LinkedHashSet

• add() - Insert the specified element into the hash set of the linked list

• addAll() - Insert all elements of the specified collection into the hash set of the linked list

For example,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
　　　　　　　　//　Use the add() method
　　　　　　　　evenNumber.add(2);
　　　　　　　　evenNumber.add(4);
　　　　　　　　evenNumber.add(6);
　　　　　　　　System.out.println("LinkedHashSet:　"　+　evenNumber);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　
　　　　　　　　//Use the addAll() method
　　　　　　　　numbers.addAll(evenNumber);
　　　　　　　　numbers.add(5);
　　　　　　　　System.out.println("New LinkedHashSet: ",　+　numbers);
　　　　}
}

Output result

LinkedHashSet:　[2,　4,　6]
New LinkedHashSet: [2,　4,　6,　5]

Access the LinkedHashSet elements

To access the elements of the hash set of the linked list, we can use the iterator() method. To use this method, we must import the java.util.Iterator package. For example,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet:　"　+　numbers);
　　　　　　　　//Invoke the iterator() method
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("Using Iterator's LinkedHashSet:　");
　　　　　　　　//Access elements
　　　　　　　　while(iterate.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

Output result

LinkedHashSet:　[2,　5,　6]
Using Iterator's LinkedHashSet:　2,　5,　6,

Precautions:

• hasNext() returns true if there is a next element in the hash set of the link

• next() returns the next element in the hash set of the link

Remove elements from the HashSet

• remove() - Remove the specified element from the hash set of the linked list

• removeAll() - Remove all elements from the hash set of the linked list

For example,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet:　"　+　numbers);
　　　　　　　　//Using the remove() method
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5Deleted?　"　+　value1);
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("Did all elements get deleted?　"　+　value2);
　　　　}
}

Output result

LinkedHashSet:　[2,　5,　6]
5Deleted?　true
Did all elements get deleted?　true

LinkedHashSet operation methods

Various methods of the LinkedHashSet class can also be used to perform various Set operations.

Union

To perform the union between two sets, we can use the addAll() method. For example,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　evenNumbers);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　numbers);
　　　　　　　　//Union of two sets
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Union:　"　+　numbers);
　　　　}
}

Output result

LinkedHashSet1: [2,　4]
LinkedHashSet2: [1,　3]
Union:　[1,　3,　2,　4]

Intersection

To perform the intersection between two sets, we can use the retainAll() method. For example

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　evenNumbers);
　　　　　　　　//Intersection of sets
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("Intersection of sets:　"　+　evenNumbers);
　　　　}
}

Output result

LinkedHashSet1: [2,　3]
LinkedHashSet2: [2,　4]
Intersection of sets:　[2]

Difference set

To calculate the difference between two sets, we can use the removeAll() method. For example,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　primeNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
　　　　　　　　oddNumbers.add(1);
　　　　　　　　oddNumbers.add(3);
　　　　　　　　oddNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　oddNumbers);
　　　　　　　　//LinkedHashSet1and LinkedHashSet2difference between
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Difference set: "　+　primeNumbers);
　　　　}
}

Output result

LinkedHashSet1: [2,　3,　5]
LinkedHashSet2: [1,　3,　5]
Difference set: [2]

Subset

To check if one collection is a subset of another, we can use the containsAll() method. For example,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　numbers);
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　primeNumbers);
　　　　　　　　//Check if primeNumbers is a subset of numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("LinkedHashSet2Is LinkedHashSet1Is it a subset? "　+　result);
　　　　}
}

Output result

LinkedHashSet1: [1,　2,　3,　4]
LinkedHashSet2: [2,　3]
LinkedHashSet2Is LinkedHashSet1Is it a subset? true

Other methods of LinkedHashSet

Differences between LinkedHashSet and HashSet

LinkedHashSet and HashSet both implement the Set interface. However, there are some differences between them.

• LinkedHashSet maintains a linked list internally. Therefore, it maintains the insertion order of its elements.

• LinkedHashSet class requires more storage space than HashSet. This is because LinkedHashSet maintains a linked list internally.

• LinkedHashSet is slower in performance than HashSet. This is because there is a linked list in LinkedHashSet.

Differences between LinkedHashSet and TreeSet

The following are the main differences between LinkedHashSet and TreeSet:

• The TreeSet class implements the SortedSet interface. This is why the elements in the tree set are ordered. However, the LinkedHashSet class only maintains the insertion order of its elements.

• TreeSet is usually slower than LinkedHashSet. This is because every time an element is added to TreeSet, it must perform a sorting operation.

• LinkedHashSet allows insertion of null values. However, we cannot insert null values into TreeSet.