Overview

LinkedHashMap maintains a doubly-linked list running through all its entries, which defines the iteration ordering. By default, it maintains insertion order, but can also be configured to maintain access order.

Basic Insertion Order Example

import java.util.*;
public class LinkedHashMapInsertionOrder {
public static void main(String[] args) {
// Creating LinkedHashMap with default insertion order
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
// Adding elements - order will be preserved
linkedHashMap.put("Apple", 1);
linkedHashMap.put("Banana", 2);
linkedHashMap.put("Orange", 3);
linkedHashMap.put("Mango", 4);
linkedHashMap.put("Grapes", 5);
System.out.println("LinkedHashMap (Insertion Order):");
linkedHashMap.forEach((key, value) -> System.out.println(key + " = " + value));
// Compare with HashMap (no order guarantee)
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
hashMap.put("Orange", 3);
hashMap.put("Mango", 4);
hashMap.put("Grapes", 5);
System.out.println("\nHashMap (No Order Guarantee):");
hashMap.forEach((key, value) -> System.out.println(key + " = " + value));
}
}

Output:

LinkedHashMap (Insertion Order):
Apple = 1
Banana = 2
Orange = 3
Mango = 4
Grapes = 5
HashMap (No Order Guarantee):
Orange = 3
Apple = 1
Grapes = 5
Banana = 2
Mango = 4

LinkedHashMap Constructors

import java.util.*;
public class LinkedHashMapConstructors {
public static void main(String[] args) {
// 1. Default constructor - insertion order
LinkedHashMap<String, Integer> map1 = new LinkedHashMap<>();
map1.put("A", 1);
map1.put("B", 2);
map1.put("C", 3);
System.out.println("Default (Insertion Order): " + map1.keySet());
// 2. With initial capacity
LinkedHashMap<String, Integer> map2 = new LinkedHashMap<>(16);
map2.put("X", 10);
map2.put("Y", 20);
map2.put("Z", 30);
System.out.println("With Capacity: " + map2.keySet());
// 3. With initial capacity and load factor
LinkedHashMap<String, Integer> map3 = new LinkedHashMap<>(16, 0.75f);
map3.put("P", 100);
map3.put("Q", 200);
map3.put("R", 300);
System.out.println("With Capacity & Load Factor: " + map3.keySet());
// 4. With initial capacity, load factor, and access order
LinkedHashMap<String, Integer> map4 = new LinkedHashMap<>(
16, 0.75f, true); // true for access order
map4.put("One", 1);
map4.put("Two", 2);
map4.put("Three", 3);
System.out.println("Before access: " + map4.keySet());
// Access some elements to change order
map4.get("One");
map4.get("Two");
System.out.println("After access: " + map4.keySet());
// 5. From existing map
Map<String, Integer> existingMap = new HashMap<>();
existingMap.put("First", 1);
existingMap.put("Second", 2);
existingMap.put("Third", 3);
LinkedHashMap<String, Integer> map5 = new LinkedHashMap<>(existingMap);
System.out.println("From existing map: " + map5.keySet());
}
}

Insertion Order vs Access Order

Insertion Order (Default)

import java.util.*;
public class InsertionOrderExample {
public static void main(String[] args) {
LinkedHashMap<String, String> insertionOrderMap = new LinkedHashMap<>();
insertionOrderMap.put("Z", "Zebra");
insertionOrderMap.put("A", "Apple");
insertionOrderMap.put("M", "Monkey");
insertionOrderMap.put("B", "Banana");
System.out.println("Insertion Order Map:");
insertionOrderMap.forEach((k, v) -> System.out.println(k + " -> " + v));
// Even after modifications, insertion order is maintained
insertionOrderMap.remove("M");
insertionOrderMap.put("C", "Cat");
insertionOrderMap.put("M", "Modified Monkey"); // Re-insert
System.out.println("\nAfter modifications:");
insertionOrderMap.forEach((k, v) -> System.out.println(k + " -> " + v));
}
}

Output:

Insertion Order Map:
Z -> Zebra
A -> Apple
M -> Monkey
B -> Banana
After modifications:
Z -> Zebra
A -> Apple
B -> Banana
C -> Cat
M -> Modified Monkey

Access Order Mode

import java.util.*;
public class AccessOrderExample {
public static void main(String[] args) {
// Third parameter 'true' enables access order
LinkedHashMap<String, String> accessOrderMap = new LinkedHashMap<>(
16, 0.75f, true);
accessOrderMap.put("A", "Apple");
accessOrderMap.put("B", "Banana");
accessOrderMap.put("C", "Cherry");
accessOrderMap.put("D", "Date");
System.out.println("Initial order: " + accessOrderMap.keySet());
// Access some elements
accessOrderMap.get("B"); // Access B
System.out.println("After accessing B: " + accessOrderMap.keySet());
accessOrderMap.get("A"); // Access A
System.out.println("After accessing A: " + accessOrderMap.keySet());
accessOrderMap.put("E", "Elderberry"); // Put also counts as access
System.out.println("After adding E: " + accessOrderMap.keySet());
accessOrderMap.get("C"); // Access C
System.out.println("After accessing C: " + accessOrderMap.keySet());
}
}

Output:

Initial order: [A, B, C, D]
After accessing B: [A, C, D, B]
After accessing A: [C, D, B, A]
After adding E: [C, D, B, A, E]
After accessing C: [D, B, A, E, C]

Real-World Use Cases

1. LRU (Least Recently Used) Cache

import java.util.*;
class LRUCache<K, V> extends LinkedHashMap<K, V> {
private final int capacity;
public LRUCache(int capacity) {
super(capacity, 0.75f, true); // Access order = true
this.capacity = capacity;
}
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > capacity;
}
public void displayCache() {
System.out.println("Cache contents (most recent first):");
List<K> keys = new ArrayList<>(keySet());
Collections.reverse(keys); // Reverse to show most recent first
for (K key : keys) {
System.out.println(key + " -> " + get(key));
}
System.out.println();
}
}
public class LRUCacheExample {
public static void main(String[] args) {
LRUCache<String, String> cache = new LRUCache<>(3);
cache.put("User1", "Data1");
cache.put("User2", "Data2");
cache.put("User3", "Data3");
cache.displayCache();
cache.get("User1"); // Access User1 - makes it most recent
cache.displayCache();
cache.put("User4", "Data4"); // This will remove eldest entry (User2)
cache.displayCache();
cache.put("User5", "Data5"); // This will remove eldest entry (User3)
cache.displayCache();
}
}

Output:

Cache contents (most recent first):
User3 -> Data3
User2 -> Data2
User1 -> Data1
Cache contents (most recent first):
User1 -> Data1
User3 -> Data3
User2 -> Data2
Cache contents (most recent first):
User4 -> Data4
User1 -> Data1
User3 -> Data3
Cache contents (most recent first):
User5 -> Data5
User4 -> Data4
User1 -> Data1

2. Maintaining Insertion Order for Configuration

import java.util.*;
public class ConfigurationManager {
private LinkedHashMap<String, String> config = new LinkedHashMap<>();
public void setConfig(String key, String value) {
config.put(key, value);
}
public void displayConfigInOrder() {
System.out.println("Configuration (in setting order):");
config.forEach((key, value) -> System.out.println(key + " = " + value));
}
public static void main(String[] args) {
ConfigurationManager manager = new ConfigurationManager();
// Set configuration in specific order
manager.setConfig("database.host", "localhost");
manager.setConfig("database.port", "5432");
manager.setConfig("app.name", "MyApp");
manager.setConfig("app.version", "1.0.0");
manager.setConfig("logging.level", "DEBUG");
manager.displayConfigInOrder();
// Update existing config - order remains based on initial insertion
manager.setConfig("database.port", "3306");
manager.setConfig("app.name", "MyUpdatedApp");
System.out.println("\nAfter updates:");
manager.displayConfigInOrder();
}
}

3. Recent Items Tracker

import java.util.*;
class RecentItemsTracker<K> {
private LinkedHashMap<K, Long> recentItems;
private final int maxSize;
public RecentItemsTracker(int maxSize) {
this.maxSize = maxSize;
this.recentItems = new LinkedHashMap<K, Long>(maxSize, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<K, Long> eldest) {
return size() > maxSize;
}
};
}
public void addItem(K item) {
recentItems.put(item, System.currentTimeMillis());
}
public void accessItem(K item) {
if (recentItems.containsKey(item)) {
recentItems.get(item); // Just access to update order
}
}
public List<K> getRecentItems() {
return new ArrayList<>(recentItems.keySet());
}
public List<K> getRecentItemsMostRecentFirst() {
List<K> items = new ArrayList<>(recentItems.keySet());
Collections.reverse(items);
return items;
}
}
public class RecentItemsExample {
public static void main(String[] args) {
RecentItemsTracker<String> tracker = new RecentItemsTracker<>(5);
tracker.addItem("Item1");
tracker.addItem("Item2");
tracker.addItem("Item3");
tracker.addItem("Item4");
tracker.addItem("Item5");
System.out.println("Initial items: " + tracker.getRecentItems());
tracker.accessItem("Item2"); // Make Item2 most recent
System.out.println("After accessing Item2: " + tracker.getRecentItems());
tracker.addItem("Item6"); // This should remove Item1 (eldest)
System.out.println("After adding Item6: " + tracker.getRecentItems());
System.out.println("Most recent first: " + tracker.getRecentItemsMostRecentFirst());
}
}

Advanced Operations

Iteration Order Preservation

import java.util.*;
public class IterationOrderExample {
public static void main(String[] args) {
LinkedHashMap<Integer, String> orderedMap = new LinkedHashMap<>();
// Add elements in specific order
for (int i = 10; i > 0; i--) {
orderedMap.put(i, "Value" + i);
}
System.out.println("Iteration order matches insertion order:");
// Entry set iteration
System.out.println("Entry Set:");
for (Map.Entry<Integer, String> entry : orderedMap.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
// Key set iteration
System.out.println("\nKey Set:");
for (Integer key : orderedMap.keySet()) {
System.out.println(key);
}
// Values iteration
System.out.println("\nValues:");
for (String value : orderedMap.values()) {
System.out.println(value);
}
}
}

Copy Preservation

import java.util.*;
public class CopyPreservationExample {
public static void main(String[] args) {
LinkedHashMap<String, Integer> original = new LinkedHashMap<>();
original.put("First", 1);
original.put("Second", 2);
original.put("Third", 3);
original.put("Fourth", 4);
System.out.println("Original: " + original.keySet());
// Copy constructor preserves order
LinkedHashMap<String, Integer> copy = new LinkedHashMap<>(original);
System.out.println("Copy: " + copy.keySet());
// PutAll preserves order
LinkedHashMap<String, Integer> anotherCopy = new LinkedHashMap<>();
anotherCopy.putAll(original);
System.out.println("PutAll Copy: " + anotherCopy.keySet());
// Sub operations may not preserve full order in some Java versions
LinkedHashMap<String, Integer> subMap = new LinkedHashMap<>();
original.entrySet().stream()
.limit(2)
.forEach(entry -> subMap.put(entry.getKey(), entry.getValue()));
System.out.println("Sub Map: " + subMap.keySet());
}
}

Performance Characteristics

import java.util.*;
public class PerformanceComparison {
public static void main(String[] args) {
int size = 100000;
// HashMap performance
long startTime = System.currentTimeMillis();
Map<Integer, String> hashMap = new HashMap<>();
for (int i = 0; i < size; i++) {
hashMap.put(i, "Value" + i);
}
long hashMapTime = System.currentTimeMillis() - startTime;
// LinkedHashMap performance (insertion order)
startTime = System.currentTimeMillis();
Map<Integer, String> linkedHashMap = new LinkedHashMap<>();
for (int i = 0; i < size; i++) {
linkedHashMap.put(i, "Value" + i);
}
long linkedHashMapTime = System.currentTimeMillis() - startTime;
// LinkedHashMap performance (access order)
startTime = System.currentTimeMillis();
Map<Integer, String> accessOrderMap = new LinkedHashMap<>(16, 0.75f, true);
for (int i = 0; i < size; i++) {
accessOrderMap.put(i, "Value" + i);
}
long accessOrderTime = System.currentTimeMillis() - startTime;
System.out.println("HashMap put time: " + hashMapTime + "ms");
System.out.println("LinkedHashMap (insertion) put time: " + linkedHashMapTime + "ms");
System.out.println("LinkedHashMap (access) put time: " + accessOrderTime + "ms");
// Iteration performance
startTime = System.currentTimeMillis();
for (String value : hashMap.values()) {
// Just iterating
}
long hashMapIteration = System.currentTimeMillis() - startTime;
startTime = System.currentTimeMillis();
for (String value : linkedHashMap.values()) {
// Just iterating
}
long linkedHashMapIteration = System.currentTimeMillis() - startTime;
System.out.println("\nHashMap iteration time: " + hashMapIteration + "ms");
System.out.println("LinkedHashMap iteration time: " + linkedHashMapIteration + "ms");
}
}

Key Points Summary

1. Insertion Order: Default mode, maintains order in which entries were added
2. Access Order: When enabled (third constructor parameter = true), maintains order based on access pattern
3. Performance: Slightly slower than HashMap due to maintaining linked list
4. Memory: Uses more memory than HashMap due to linked list overhead
5. Thread Safety: Not synchronized - use Collections.synchronizedMap() if needed
6. Use Cases:

• LRU Caches
• Maintaining configuration order
• Recent items tracking
• Any scenario where iteration order matters

Best Practices

import java.util.*;
public class LinkedHashMapBestPractices {
public static void main(String[] args) {
// 1. Use appropriate initial capacity
LinkedHashMap<String, String> map1 = new LinkedHashMap<>(100);
// 2. Use access order for LRU caches
LinkedHashMap<String, String> lruCache = new LinkedHashMap<>(
16, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
return size() > 1000;
}
};
// 3. For thread safety
Map<String, String> synchronizedMap = 
Collections.synchronizedMap(new LinkedHashMap<>());
// 4. Preserve order during copy
LinkedHashMap<String, Integer> original = new LinkedHashMap<>();
original.put("A", 1);
original.put("B", 2);
LinkedHashMap<String, Integer> copy = new LinkedHashMap<>(original);
// 5. Iterate efficiently
for (Map.Entry<String, Integer> entry : copy.entrySet()) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}
}
}

LinkedHashMap is the perfect choice when you need HashMap's performance characteristics combined with predictable iteration order, making it invaluable for many real-world applications.