Java LinkedHashSet (original) (raw)

Last Updated : 17 Dec, 2024

Try it on GfG Practice

**LinkedHashSet in Java implements the Set interface of the Collection Framework. It combines the functionality of a HashSet with a **LinkedList to maintain the insertion order of elements.

• Stores unique elements only.
• Maintains insertion order.
• Provides faster iteration compared to HashSet.
• Allows null elements.

**Example:

Java `

import java.util.LinkedHashSet;

public class Geeks { public static void main(String[] args) {

    // Create a LinkedHashSet of Strings
    LinkedHashSet<String> lh = new LinkedHashSet<>();
    
    System.out.println("" + lh);
}

}

`

**Hierarchy of LinkedHashSet

Declaring a LinkedHashSet

public class LinkedHashSet extends HashSet implements Set, Cloneable, Serializable

where, E is the type of elements maintained by this set.

The **LinkedHashSet is an ordered version of HashSet that maintains a doubly-linked List across all elements. When the iteration order is needed to be maintained this class is used. When iterating through a HashSet the order is unpredictable, while a LinkedHashSet lets us iterate through the elements in the order in which they were inserted. When cycling through LinkedHashSet using an iterator, the elements will be returned in the order in which they were inserted.

Constructors of LinkedHashSet Class

1. **LinkedHashSet(): This constructor is used to create an empty LinkedHashSet with the default capacity i.e. 16 and load factor 0.75.

LinkedHashSet hs = new LinkedHashSet();

**2. LinkedHashSet(Collection C): Used in initializing the HashSet with the elements of the collection C.

LinkedHashSet hs = new LinkedHashSet(Collection c);

**3. LinkedHashSet(int size): Used to initialize the size of the LinkedHashSet with the integer mentioned in the parameter.

LinkedHashSet hs = new LinkedHashSet(int size);

**4. LinkedHashSet(int capacity, float fillRatio): Can be used to initialize both the capacity and the fill ratio, also called the load capacity of the LinkedHashSet with the arguments mentioned in the parameter. When the number of elements exceeds the capacity of the hash set is multiplied with the fill ratio thus expanding the capacity of the LinkedHashSet.

LinkedHashSet hs = new LinkedHashSet(int capacity, int fillRatio);

Methods of LinkedHashSet

Here are some commonly used methods in LinkedHashSet:

Methods Declared in java.util.AbstractSet Class

Methods Declared in java.util.AbstractCollection Class

Methods Declared in java.util.Collection Interface

Methods Declared in java.util.HashSet Class

**Methods declared in java.lang.Iterable Interface

**Methods Declared in java.util.Set Interface

Performing Various Operations on LinkedHashSet

Let’s see how to perform a few frequently used operations on the LinkedHashSet.

**1. Adding Elements in LinkedHashSet

In order to add an element to the LinkedHashSet, we can use the add() method. This is different from HashSet because in HashSet, the insertion order is not retained but is retained in the LinkedHashSet.

**Example:

Java `

import java.io.; import java.util.;

class Geeks {

public static void main(String[] args) {

    // Creating an empty LinkedHashSet
    LinkedHashSet<String> lh = new LinkedHashSet<String>();

    // Adding elements to above Set
    // using add() method
    lh.add("Geek");
    lh.add("For");
    lh.add("Geeks");

    System.out.println("LinkedHashSet : " + lh);
}

}

`

Output

LinkedHashSet : [Geek, For, Geeks]

2. Removing Elements in LinkedHashSet

The values can be removed from the LinkedHashSet using the remove() method.

**Example:

Java `

import java.io.; import java.util.;

class Geeks {

public static void main(String[] args) {

    // Creating an empty LinekdhashSet of string type
    LinkedHashSet<String> lh
        = new LinkedHashSet<String>();

    // Adding elements to above Set
    // using add() method
    lh.add("Geek");
    lh.add("For");
    lh.add("Geeks");
    lh.add("A");
    lh.add("B");
    lh.add("Z");

    System.out.println("" + lh);

    // Removing the element from above Set
    lh.remove("B");

    // Again removing the element
    System.out.println("After removing element " + lh);

    // Returning false if the element is not present
    System.out.println(lh.remove("AC"));
}

}

`

Output

[Geek, For, Geeks, A, B, Z] After removing element [Geek, For, Geeks, A, Z] false

3. Iterating through the LinkedHashSet

Iterate through the elements of LinkedHashSet using the iterator() method. The most famous one is to use the enhanced for loop.

**Example:

Java `

import java.io.; import java.util.;

class Geeks {

public static void main(String[] args) {

    // Instantiate an object of Set
    // Since LinkedHashSet implements Set
    // Set points to LinkedHashSet
    Set<String> lh = new LinkedHashSet<String>();

    lh.add("Geek");
    lh.add("For");
    lh.add("Geeks");
    lh.add("A");
    lh.add("B");
    lh.add("Z");

    // Iterating though the LinkedHashSet
    // using iterators
    Iterator itr = lh.iterator();

    while (itr.hasNext())
        System.out.print(itr.next() + ", ");

    System.out.println();

    // Using enhanced for loop for iteration
    for (String s : lh)
        System.out.print(s + ", ");
    System.out.println();
}

}

`

Output

Geek, For, Geeks, A, B, Z, Geek, For, Geeks, A, B, Z,

Advantages of LinkedHashSet

• It maintains insertion order.
• It allows quick insertion, deletion, and lookup of elements.
• It is useful for caching applications where insertion order is important.

Disadvantages of LinkedHashSet

• It takes higher memory as compared to HashSet due to the linked list for maintaining insertion order.
• This is slightly slower operations compared to HashSet because of the linked structure.

LinkedHashMap vs LinkedHashSet

**Note: Keeping the insertion order in both LinkedHashmap and LinkedHashset have additional associated costs, both in terms of spending additional CPU cycles and needing more memory. If you do not need the insertion order maintained, it is recommended to use the lighter-weight HashSet and HashMap instead.