Speaking of the LinkedHashSet class in Java, we need to mention that it implements the Set interface. LinkedHashSet creates a collection that stores elements in a hash table but maintains the insertion order of elements unlike its HashSet counterpart.
What is Set in Java
Let us briefly recall that the Set interface defines a set (set). It extends Collection and defines the behavior of collections that do not allow duplicate elements. Thus, the add() method returns false if an attempt is made to add a duplicate element to the set.
The interface does not define any additional methods of its own.
The Set interface takes care of the uniqueness of stored objects, uniqueness is determined by the implementation of the equals() method. Therefore, if objects of the created class will be added to the Set, it is desirable to override the equals() method.
LinkedHashSet class
Before talking about the LinkedHashSet class, we need to mention its close relative, the HashSet class. HashSet implements the Set interface. It creates a collection that stores the elements in a hash table. The elements of a hash table are stored as key-value pairs. The key specifies the cell (or segment) to store the value. The content of the key is used to determine a unique value called a hash code. We can think of a hash code as an object identifier, although it doesn't have to be unique. This hash code also serves as an index to which the data associated with the key is stored.
The LinkedHashSet Java class extends HashSet without adding any new methods. LinkedHashSet allows you to quickly check for the existence of an entry, just like HashSet, but contains an ordered list inside. This means that it stores the insertion order of the elements. In other words, LinkedHashSet maintains a linked list of set elements in the order they were inserted. This allows ordered iteration of insertion into a set. But this causes the LinkedHashSet class to perform operations longer than the HashSet class.
Important Features of LinkedHashSet
We can store unique elements only in a LinkedHashSet
LinketHashSet let us to extract elements in the same order that we insert
LinkedHashSet is Not Synchronized
LinkedHashSet allows storing null elements
LinkedHashSet uses a hashing technique to store elements at a specified index based on a hash code
LinkedHashSet Methods
In addition to the methods inherited from its parent classes, HashSet defines the following methods:
boolean add(Object o) adds the specified element to this set if it is not already present.
void clear() removes all elements from this set.
Object clone() returns a shallow copy of this LinkedHashSet instance: the elements themselves are not cloned.
boolean contains(Object o) returns true if this set contains the specified element.
boolean isEmpty() returns true if this set contains no elements.
Iterator iterator() returns an iterator over the elements of this set.
boolean remove(Object o) removes the specified element from this set, if present.
int size() returns the number of elements in this set (its number of elements).
Easy LinkedHashSet examplesIn the example below we show initialization of the LinkedHashSet object and using add() method to fill the set in.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx1 {
public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
set.add("Re"); //first added element
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");//last added element
System.out.println(set);
}
}
The output is:
[Re, Do, Fa, Sol, La, Ti, Mi]
As you can see, the elements in our set appeared in the same order that we placed them in.
Example 2. Adding a duplicate into LinkedHashSet
Let’s put in our LinkedHashSet 7 elements with names of musical scores again and put one new element that is the same as one of elements placed before.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx2 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
set.add("Sol");
System.out.println(set);
}
}
The output of the program is here:
[Re, Do, Fa, Sol, La, Ti, Mi]
The output of Example two is exactly the same as in the first example. We can’t have two similar elements in the LinkedHashSet collection. When we try to put the second one, it’s just ignored.
Example 3. Removing elements from LinkedHashSet
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSet3 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
System.out.println(set);
set.remove("Fa");// removing an element from our set
set.remove("Score");//trying to remove element that isn't in set
System.out.println(set.remove("Score"));
System.out.println("Print our set without elements removed: ");
System.out.println(set);
set.clear();
System.out.println("Print out our set after clear command: ");
System.out.println(set);
}
}
The output of the program is here:
[Re, Do, Fa, Sol, La, Ti, Mi]
false
Print our set without elements removed:
[Re, Do, Sol, La, Ti, Mi]
Print out our set after clear command:
[]
As you can see, the remove() method applied to a non-existent element does not result in a program error. It simply returns false if the element was not removed and true if the element was in the LinkedHashSet and then removed.
LinkedHashSet vs HashSet
These two classes are close relatives. However inside the HashSet it uses HashMap to store objects while LinkedHashSet uses LinkedHashMap. If you don’t need to maintain insertion order but need to store unique objects, it is more appropriate to use HashSet. If you need to maintain the insertion order of elements then LinkedHashSet is your choice. The performance of LinkedHashSet is a bit slower than HashSet because LinkedHashSet uses internal LinkedList to maintain the insertion order of elements. Let’s have an example:
import java.util.*;
public class LinkedHashSetExample1 {
public static void main(String[] args) {
// while regular hash set orders its elements according to its hashcode stamps
Set<Integer> regularHashSet = new HashSet<>();
regularHashSet.add(7);
regularHashSet.add(3);
regularHashSet.add(5);
regularHashSet.add(65536);
regularHashSet.add(9);
// few duplicates
regularHashSet.add(5);
regularHashSet.add(7);
// next will print:
// > regularHashSet = [65536, 3, 5, 7, 9]
System.out.println("regularHashSet = " + regularHashSet);
// linked hash set keeps order of adding unchanged
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(7);
linkedHashSet.add(3);
linkedHashSet.add(5);
linkedHashSet.add(65536);
linkedHashSet.add(9);
// few duplicates
linkedHashSet.add(5);
linkedHashSet.add(7);
// next will print:
// > linkedHashSet = [7, 3, 5, 65536, 9]
System.out.println("linkedHashSet = " + linkedHashSet);
}
}
Using Java LinkedHashSet in real world applications
Since LinkedHashSet allows you to quickly check for the existence of an entry and also stores order, this collection seems to be quite convenient for eliminating duplicates from a list. Or, for example, solving problems like the last recently seen item in my bag. Or, remember such a game, Pokemon Go? LinkedHashSet can store a list of Pokémon you've encountered and the order in which they came across on your path. In this case, the “repeated” Pokémon will no longer be added to the list. Or, for example, a list of bosses by level that you have already met in any game with levels. Or the history of the discovery of cosmic bodies. LinkedHashSet allows you to quickly check whether a space body is already in the list or not, and if it is not there, then add it to the list. Let's take an example of eliminating duplicates.
import java.util.*;
class LinkedHashSetExample2 {
public static void main(String[] args) {
List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");
Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);
// next will print:
// > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
System.out.println("listWithDuplicates = " + listWithDuplicates);
// next will print:
// > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);
// -------------------------------------------------------------------------
// while using regular Hash Set will generally produces some unexpected order
Set<String> regularHashSet = new HashSet<>(listWithDuplicates);
// next will print:
// > linkedHashSet = [some, elements, with, few, duplicates, were, here]
System.out.println("linkedHashSet = " + linkedHashSet);
// next will print:
// > regularHashSet = [here, some, with, duplicates, were, elements, few]
System.out.println("regularHashSet = " + regularHashSet);
}
}
GO TO FULL VERSION