DEV Community

Cover image for Java LinkedHashSet Explained: The Ordered & Unique Collection
Satyam Gupta
Satyam Gupta

Posted on

Java LinkedHashSet Explained: The Ordered & Unique Collection

#java #set #webdev

Java LinkedHashSet Explained: Why Order and Uniqueness are a Game Changer

Alright, let's talk about Java Collections. You've probably been there: you're adding items to a HashSet because you need no duplicates, but then you print the set and... wait, why is everything all jumbled up? The order is completely random! It’s frustrating, right?

And then you think, "I know! I'll use a LinkedList!" But then you have to manually check for duplicates every time you add an element. That’s just extra code and a potential source of bugs.

So, what's the solution? Enter the unsung hero of the Java Collections Framework: the LinkedHashSet.

In this deep dive, we're going to break down everything about LinkedHashSet. What it is, how it works under the hood, when to use it, and when not to. By the end of this, you'll have a new favorite tool in your Java toolkit.

So, What Exactly is a LinkedHashSet?
In simple terms, a LinkedHashSet is the perfect lovechild of a HashSet and a LinkedList. It gives you the best of both worlds:

Uniqueness of Elements: Just like a HashSet, it does not allow duplicate elements. Try to add the same object twice, and it will silently ignore the second request.

Predictable Iteration Order: This is the killer feature. Unlike a HashSet, a LinkedHashSet maintains a doubly-linked list running through all of its entries. This linked list defines the iteration order, which is the order in which elements were inserted into the set.

Let's get a bit technical. LinkedHashSet extends HashSet and implements the Set interface. Internally, it uses a hash table for fast lookups (like HashSet), but it also maintains a linked list to preserve the insertion order.

The Bottom Line: If you need a Set that remembers what you added and in what sequence, LinkedHashSet is your go-to.

Code in Action: Let's See LinkedHashSet Working
Enough theory. Let's look at some code to see the magic happen. We'll compare it directly with a HashSet so you can see the difference side-by-side.

java
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        // Let's create a HashSet and a LinkedHashSet
        Set<String> hashSet = new HashSet<>();
        Set<String> linkedHashSet = new LinkedHashSet<>();

        // Adding some fruits (in a specific order)
        String[] fruits = {"Apple", "Mango", "Banana", "Orange", "Apple"}; // Note the duplicate "Apple"

        System.out.println("Adding fruits: Apple, Mango, Banana, Orange, Apple (duplicate)");
        System.out.println("-------------------------------------------------------------");

        for (String fruit : fruits) {
            hashSet.add(fruit);
            linkedHashSet.add(fruit);
        }

        // Printing the sets
        System.out.println("HashSet contents      : " + hashSet);
        System.out.println("LinkedHashSet contents: " + linkedHashSet);
    }
}
Enter fullscreen mode Exit fullscreen mode

What do you think the output will be?

Run this code, and you'll likely see something like this:

text

Adding fruits: Apple, Mango, Banana, Orange, Apple (duplicate)

HashSet contents : [Apple, Orange, Banana, Mango]
LinkedHashSet contents: [Apple, Mango, Banana, Orange]
See the difference?

HashSet: The order is all over the place. It's based on the internal hash buckets, which is useless for us humans.

LinkedHashSet: The order is perfectly preserved! Apple, Mango, Banana, Orange. And notice how the duplicate "Apple" was gracefully ignored. This predictability is a lifesaver in many situations.

Real-World Use Cases: Where Would I Actually Use This?
"This is cool," you might be thinking, "but is this just an academic concept?" Absolutely not! LinkedHashSet shines in several real-world scenarios.

  1. Creating a Deduplicated History or Log Imagine you're building a feature that shows a user their recently viewed products. You don't want duplicates, and you want to show them in the order they were viewed. 
java
LinkedHashSet<String> recentlyViewed = new LinkedHashSet<>(5); // Rough capacity hint

// User views some products
recentlyViewed.add("product_123");
recentlyViewed.add("product_456");
recentlyViewed.add("product_123"); // Oops, viewed again! Won't be added.
recentlyViewed.add("product_789");
Enter fullscreen mode Exit fullscreen mode

System.out.println("Recently Viewed: " + recentlyViewed);
// Output: [product_123, product_456, product_789]

  1. Implementing a Cache with LRU (Least Recently Used) Eviction This is a more advanced but super powerful use case. You can extend LinkedHashSet and override its removeEldestEntry method to create a simple, fixed-size cache that automatically removes the oldest item when it gets full. 
java
import java.util.LinkedHashSet;

class LRUCache<K> extends LinkedHashSet<K> {
    private final int maxSize;

    public LRUCache(int maxSize) {
        this.maxSize = maxSize;
    }

    @Override
    public boolean add(K key) {
        // If the key already exists, remove it first so it gets added to the end (as most recent)
        if (contains(key)) {
            remove(key);
        }
        boolean added = super.add(key);
        // If we're over capacity, remove the oldest entry (the first one)
        if (size() > maxSize) {
            remove(this.iterator().next());
        }
        return added;
    }
}
Enter fullscreen mode Exit fullscreen mode

// Using our LRU Cache
LRUCache cache = new LRUCache<>(3);
cache.add("A");
cache.add("B");
cache.add("C");
System.out.println(cache); // [A, B, C]

cache.add("D"); // Adds D, which pushes out the oldest (A)
System.out.println(cache); // [B, C, D]

cache.add("C"); // Re-accesses C, moving it to the end
System.out.println(cache); // [B, D, C]

  1. Processing Data While Maintaining Sequence Let's say you're reading lines from a log file, and you want to collect unique error codes, but you need to know which error occurred first. LinkedHashSet is perfect for this.

Best Practices and The Fine Print
No data structure is a silver bullet. Here are some things to keep in mind:

Performance: LinkedHashSet has slightly lower performance than HashSet because of the overhead of maintaining the linked list. Insertion, removal, and lookup are still O(1) on average, but the constants are higher. For most applications, this difference is negligible. Don't optimize prematurely!

Memory Footprint: It uses a bit more memory than HashSet due to the extra storage needed for the linked list nodes (the before and after references).

Synchronization: Just like HashSet, LinkedHashSet is not thread-safe. If multiple threads access it concurrently and at least one modifies it, you must synchronize it externally. You can use Collections.synchronizedSet(new LinkedHashSet()) for a quick fix.

Null Elements: Yes, you can add a null element to a LinkedHashSet.

FAQ Section: Clearing the Air
Q1: When should I use LinkedHashSet over HashSet?
Use LinkedHashSet when you require both uniqueness and insertion-order iteration. If you only need uniqueness and don't care about order, stick with HashSet for its slightly better performance.

Q2: How is it different from a TreeSet?
A TreeSet also maintains uniqueness but sorts elements based on their natural ordering (or a custom Comparator). LinkedHashSet maintains insertion order, not sorted order.

Q3: Is the order affected if I re-insert an element?
No. If you try to add an element that's already in the set, the insertion order remains unchanged. The element stays in its original position.

Q4: Can I get the first or last element easily?
Not directly through the Set interface. Since it maintains insertion order, the first element is the one you get by calling iterator().next(). The last element isn't as straightforward; you'd have to iterate to the end or use other collection utilities.

Conclusion: Wrapping It Up
The Java LinkedHashSet is a deceptively simple class that solves a very specific but common problem: maintaining uniqueness without sacrificing order. It's a robust, efficient, and often overlooked component of the Java Collections Framework.

By understanding its internal mechanics (the hash table + linked list combo), you can make informed decisions about when to leverage its power. Whether it's for building a recent items list, a simple LRU cache, or just processing unique data in sequence, LinkedHashSet is a tool that deserves a prime spot in your developer toolbox.

Mastering these core Java concepts is what separates good developers from great ones.

Ready to level up your software development skills and master Java, advanced data structures, and much more? To learn professional software development courses such as Python Programming, Full Stack Development, and MERN Stack, visit and enroll today at codercrafter.in. We break down complex topics into easy-to-understand modules to help you build a stellar career!

Top comments (0)