Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java LinkedHashSet — insertion-order preservation, internal working backed by LinkedHashMap, comparison with HashSet and TreeSet, and practical use cases.
What is LinkedHashSet?
java.util.LinkedHashSet is a HashSet with predictable iteration order. It maintains a doubly-linked list across all entries, preserving the insertion order of elements.
java example
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, SerializableThink of it as: HashSet performance + insertion order guarantee.
Characteristics
| Feature | LinkedHashSet |
|---|---|
| Duplicates | Not allowed |
| Ordering | Insertion order preserved |
| Null elements | One null allowed |
| Performance | O(1) for add/remove/contains |
| Backed by | LinkedHashMap |
| Thread-safe | No |
| Memory | More than HashSet (linked list pointers) |
Basic Usage
Example
import java.util.*;
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
// Elements maintain insertion order
set.add("Cherry");
set.add("Apple");
set.add("Banana");
set.add("Date");
set.add("Apple"); // Duplicate — NOT added, position unchanged
System.out.println("Set: " + set);
// Output: [Cherry, Apple, Banana, Date] — insertion order!
// Compare with HashSet (unpredictable order)
Set<String> hashSet = new HashSet<>(set);
System.out.println("HashSet: " + hashSet);
// Output: might be [Apple, Banana, Cherry, Date] or any order
// Iteration is always in insertion order
System.out.println("\nIteration:");
for (String item : set) {
System.out.println(" " + item);
}
// Always: Cherry, Apple, Banana, Date
// Operations
set.remove("Banana");
System.out.println("After removing Banana: " + set);
// [Cherry, Apple, Date] — order preserved
set.add("Banana"); // Re-adding goes to the END
System.out.println("After re-adding Banana: " + set);
// [Cherry, Apple, Date, Banana] — new insertion position
}
}
Output
Set: [Apple, Banana, Cherry, Date] Insertion order preserved! Duplicate Apple added? false Set still: [Apple, Banana, Cherry, Date] After remove Cherry: [Apple, Banana, Date]
Constructors
Example
// Default: capacity 16, load factor 0.75
Set<String> set1 = new LinkedHashSet<>();
// Custom initial capacity
Set<String> set2 = new LinkedHashSet<>(50);
// Custom capacity and load factor
Set<String> set3 = new LinkedHashSet<>(50, 0.8f);
// From another collection (preserves that collection's iteration order)
List<String> list = Arrays.asList("C", "A", "B", "A", "C");
Set<String> set4 = new LinkedHashSet<>(list);
System.out.println(set4); // [C, A, B] — first-occurrence order, no dupes
Time Complexity
| Operation | Average | Worst Case |
|---|---|---|
| ----------- | :-: | :-: |
add(E e) | O(1) | O(log n)* |
remove(Object o) | O(1) | O(log n)* |
contains(Object o) | O(1) | O(log n)* |
size() | O(1) | O(1) |
| Iteration | O(n) | O(n) |
*With treeification (Java 8+)
Iteration Performance: LinkedHashSet vs HashSet
| Set Type | Iteration Time |
|---|---|
| ---------- | :-: |
| HashSet | O(capacity + n) — traverses all buckets including empty |
| LinkedHashSet | O(n) — follows linked list, only visits actual elements |
This means LinkedHashSet iterates faster when the set is sparse (few elements relative to capacity).
Practical Use Cases
1. Remove Duplicates While Preserving Order
This is the #1 use case for LinkedHashSet:
Example
List<String> input = Arrays.asList("banana", "apple", "cherry", "apple", "banana", "date");
// Remove duplicates, keep first-occurrence order
List<String> unique = new ArrayList<>(new LinkedHashSet<>(input));
System.out.println(unique); // [banana, apple, cherry, date]
2. Maintaining Display Order
java example
// Menu items should display in the order they were added
Set<String> menuItems = new LinkedHashSet<>();
menuItems.add("Home");
menuItems.add("Products");
menuItems.add("About");
menuItems.add("Contact");
// Always renders: Home → Products → About → Contact
for (String item : menuItems) {
renderMenuItem(item);
}3. Processing Unique Items in Order
java example
// Process each unique URL in the order it was discovered
Set<String> visitedUrls = new LinkedHashSet<>();
visitedUrls.add("https://example.com");
visitedUrls.add("https://example.com/about");
visitedUrls.add("https://example.com"); // Already visited
visitedUrls.add("https://example.com/products");
// Process in discovery order
for (String url : visitedUrls) {
crawl(url);
}4. Ordered Set Operations
Example
Set<String> set1 = new LinkedHashSet<>(Arrays.asList("A", "B", "C", "D"));
Set<String> set2 = new LinkedHashSet<>(Arrays.asList("C", "D", "E", "F"));
// Intersection (preserves order from set1)
Set<String> intersection = new LinkedHashSet<>(set1);
intersection.retainAll(set2);
System.out.println(intersection); // [C, D]
// Union (set1 order first, then new elements from set2)
Set<String> union = new LinkedHashSet<>(set1);
union.addAll(set2);
System.out.println(union); // [A, B, C, D, E, F]
LinkedHashSet vs HashSet vs TreeSet
| Feature | HashSet | LinkedHashSet | TreeSet |
|---|---|---|---|
| Ordering | None | Insertion order | Sorted (natural/comparator) |
| add/remove/contains | O(1) | O(1) | O(log n) |
| Iteration | O(capacity) | O(n) | O(n) |
| Backed by | HashMap | LinkedHashMap | TreeMap |
| Null elements | One | One | ❌ None |
| Memory overhead | Lowest | Medium | Highest |
| Use when | Don't care about order | Need insertion order | Need sorted order |
When to Use Which
java example
// Don't care about order — use HashSet (fastest)
Set<String> lookupOnly = new HashSet<>();
// Need insertion order — use LinkedHashSet
Set<String> orderedUnique = new LinkedHashSet<>();
// Need sorted order — use TreeSet
Set<String> sorted = new TreeSet<>();
// Need concurrent access — use ConcurrentHashMap.newKeySet()
Set<String> concurrent = ConcurrentHashMap.newKeySet();Important Behavior Details
Re-insertion Doesn't Change Position
Example
Set<String> set = new LinkedHashSet<>(Arrays.asList("A", "B", "C"));
set.add("A"); // "A" already exists — position stays at beginning
System.out.println(set); // [A, B, C] — NOT moved to end!
Removal and Re-addition Changes Position
Example
Set<String> set = new LinkedHashSet<>(Arrays.asList("A", "B", "C"));
set.remove("A"); // Remove A
set.add("A"); // Re-add A — goes to END
System.out.println(set); // [B, C, A]
Converting Between Set Types
Example
// Preserve order when converting
Set<String> hashSet = new HashSet<>(Arrays.asList("C", "A", "B"));
Set<String> ordered = new LinkedHashSet<>(hashSet);
// Order is whatever hashSet's iteration gives — NOT alphabetical!
// For alphabetical, use TreeSet
Set<String> sorted = new TreeSet<>(hashSet);
// Always [A, B, C]
Thread Safety
java example
// Option 1: Synchronized wrapper
Set<String> syncSet = Collections.synchronizedSet(new LinkedHashSet<>());
// Option 2: Manual synchronization
private final Set<String> set = new LinkedHashSet<>();
private final Object lock = new Object();
public void addItem(String item) {
synchronized (lock) {
set.add(item);
}
}Note: There is no ConcurrentLinkedHashSet in the JDK. For concurrent ordered sets, consider third-party libraries or use ConcurrentHashMap.newKeySet() (which doesn't preserve insertion order).
Common Mistakes
1. Assuming HashSet Preserves Order
java example
// WRONG assumption
Set<String> set = new HashSet<>();
set.add("First");
set.add("Second");
set.add("Third");
// Iteration may NOT be: First, Second, Third!
// CORRECT — use LinkedHashSet for insertion order
Set<String> set = new LinkedHashSet<>();2. Mutating Elements After Adding
java example
// Same problem as HashSet — mutable elements break the set
List<String> item = new ArrayList<>(Arrays.asList("A"));
Set<List<String>> set = new LinkedHashSet<>();
set.add(item);
item.add("B"); // hashCode changes — element is LOST!3. Not Understanding Memory Overhead
java example
// LinkedHashSet uses more memory than HashSet
// Each entry has two extra pointers (before/after)
// For millions of elements, this adds up (~16 bytes per element extra)
// If you don't need order, use HashSet to save memoryPerformance Comparison (Benchmark)
java example
// For 1 million elements:
// Operation | HashSet | LinkedHashSet | TreeSet
// add() | ~120ms | ~150ms | ~800ms
// contains() | ~40ms | ~45ms | ~350ms
// iteration | ~50ms | ~35ms | ~45ms
// memory | ~48MB | ~64MB | ~80MB
// Key insight: LinkedHashSet iterates FASTER than HashSet
// because it doesn't traverse empty bucketsInterview Questions
Q1: How does LinkedHashSet maintain insertion order?
A: It's backed by a LinkedHashMap (not HashMap). LinkedHashMap maintains a doubly-linked list threading through all entries, preserving insertion order.
Q2: What is the difference between LinkedHashSet and HashSet?
A: LinkedHashSet maintains insertion order (predictable iteration). HashSet has no ordering guarantee. LinkedHashSet uses slightly more memory for the linked list pointers.
Q3: Does adding a duplicate element change its position in LinkedHashSet?
A: No. If the element already exists, add() returns false and the element's position in the iteration order remains unchanged.
Q4: What is the time complexity of LinkedHashSet operations?
A: Same as HashSet — O(1) average for add, remove, contains. Iteration is O(n), which is actually better than HashSet's O(capacity + n).
Q5: When should you use LinkedHashSet over HashSet?
A: When you need: (1) unique elements, (2) O(1) operations, AND (3) predictable insertion-order iteration. If you don't need order, HashSet saves memory.
Q6: Can LinkedHashSet maintain access order like LinkedHashMap?
A: No. LinkedHashSet only supports insertion order. Access order (reordering on reads) is only available in LinkedHashMap directly.
Q8: How does LinkedHashSet maintain insertion order?
A: LinkedHashSet extends HashSet but uses a LinkedHashMap internally (instead of HashMap). LinkedHashMap maintains a doubly-linked list threading through all entries in insertion order. During iteration, this linked list is traversed, giving predictable insertion-order iteration.
Q9: What is the performance difference between HashSet and LinkedHashSet?
A: Near-identical for add/remove/contains — both O(1). LinkedHashSet has slightly higher memory overhead (two extra pointers per entry for the linked list) and marginally slower add/remove (maintaining linked list). However, iteration is faster: O(n) for LinkedHashSet vs O(capacity) for HashSet.
Q10: When should you use LinkedHashSet over HashSet?
A: When insertion order matters for iteration, when you need predictable iteration order in tests, when implementing ordered unique collections (like maintaining the order of user actions), or when building ordered result sets that need deduplication while preserving first-occurrence order.
Q11: Does LinkedHashSet support access-order like LinkedHashMap?
A: No. LinkedHashSet always maintains insertion-order only. There's no constructor flag to enable access-order. If you need access-order set behavior, you'd need to build a custom implementation using LinkedHashMap with access-order enabled.
Q12: How do you convert a List to a LinkedHashSet and back while preserving order?
A: List → LinkedHashSet: new LinkedHashSet<>(list) — removes duplicates while preserving first-occurrence order. LinkedHashSet → List: new ArrayList<>(linkedHashSet) — the list will have elements in the set's iteration (insertion) order, with duplicates removed.
Summary
| Aspect | LinkedHashSet |
|---|---|
| Backed by | LinkedHashMap |
| Order | Insertion order |
| Performance | O(1) — same as HashSet |
| Extra cost | ~16 bytes per element for linked list |
| Null | One null allowed |
| Primary use | Remove duplicates preserving order |
| Thread-safe | No |
| When to choose | Need Set + order; don't need sorting |
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for LinkedHashSet in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, collections, framework, set
Related Java Master Course Topics
Continue learning this concept
Collections FrameworkHashSet in JavaComplete guide to Java HashSet — internal working backed by HashMap, hashing mechanism, duplicate detection, equals/hashCode contract, performance analysis, and practical examples.Collections FrameworkTreeSet in JavaComplete guide to Java TreeSet — Red-Black tree implementation, NavigableSet operations, natural and custom ordering, range queries, ceiling/floor methods, and practical examples.Collections FrameworkCollections Framework OverviewComplete guide to Java Collections Framework covering hierarchy, interfaces, implementations, algorithms, and choosing the right collection for your use case.Collections FrameworkCollections Practice ProgramsComprehensive Java Collections practice programs covering List, Set, Map, Queue operations with solutions, explanations, and time complexity analysis.Collections FrameworkComparable vs Comparator in JavaDeep dive into Comparable and Comparator interfaces in Java — natural ordering, custom sorting, lambda expressions, method references, and practical comparisons with examples.Collections FrameworkGenerics in JavaComplete guide to Java Generics — type parameters, bounded types, wildcards, type erasure, generic methods, generic classes, and common patterns with practical examples.