HashMap vs LinkedHashMap in Java

In this article, we will learn the differences between HashMap and LinkedHashMap in Java with examples.

HashMap is an implementation of the Map interface that stores elements as key-value pairs in a hash table. This guarantees no particular order of the stored keys and values. 

LinkedHashMap is a class that extends HashMap and uses a doubly-linked list to maintain the insertion order of its key-value pairs. Optionally, it can also be configured to order entries by their access frequency.

HashMap vs LinkedHashMap: Key Points Comparison 

Ordering of Elements: 

HashMap: This does not guarantee any specific order of the keys or values. 

LinkedHashMap: Maintains the order of elements based on their insertion order. Optionally, it can also be configured to maintain the order of elements based on their access order. 

Internal Data Structure: 

HashMap: Primarily uses a hash table to store key-value pairs. 

LinkedHashMap: Uses both a hash table and a doubly-linked list. The hash table provides the primary structure for the key-value pairs, while the linked list maintains the order of the elements. 


HashMap: Typically provides slightly better performance for basic operations like add(), get(), and remove() since it directly uses hashing without any overhead of maintaining order. 

LinkedHashMap: Might be slightly slower than HashMap for the basic operations due to the added overhead of maintaining the doubly-linked list to keep the order of elements. 

Memory Usage: 

HashMap: Uses less memory as it stores only the key-value pairs. 

LinkedHashMap: Uses more memory than HashMap because it needs to maintain the pointers for the doubly-linked list, in addition to the key-value pairs. 


HashMap: Ideal when you only need a map to store key-value pairs without any concern for the order of entries. 

LinkedHashMap: Perfect for situations where you'd like to retain the order of insertion of entries, such as caching scenarios where eviction policies like LRU (Least Recently Used) might be implemented.


HashMap: Iterating over the entries can yield a different order each time (though this is not guaranteed). 

LinkedHashMap: Iterating over the entries will always yield them in the order they were inserted or accessed, depending on the configuration. 

Null Handling: 

Both HashMap and LinkedHashMap can store one null key and multiple null values. 


HashMap: Directly implements the Map interface. 

LinkedHashMap: Extends HashMap and, thus, inherits all its methods and attributes.


Using HashMap:

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 85);
scores.put("Bob", 90);
scores.put("Charlie", 88);



{Alice=85, Charlie=88, Bob=90}

The output order may differ, as HashMap doesn't guarantee any order. 

Using LinkedHashMap:

Map<String, Integer> scores = new LinkedHashMap<>();
scores.put("Alice", 85);
scores.put("Bob", 90);
scores.put("Charlie", 88);



{Alice=85, Bob=90, Charlie=88}

HashMap vs LinkedHashMap: Summary Table


HashMap is perfect for situations where you need fast storage and retrieval without any concern for the order of entries. It provides slightly better performance and is more memory-efficient compared to LinkedHashMap.

Use LinkedHashMap when there's a requirement to maintain the order of insertion. For instance, when you're storing cache entries and need to implement a Least Recently Used (LRU) eviction scheme, LinkedHashMap can be invaluable.