HashMap vs LinkedHashMap

In this article, we will discuss difference between HashMap and LinkedHashMap classes in detail i.e.; HashMap vs LinkedHashMap

Lets us move on and discuss key differences between these 2 Map implemented classes

HashMap v/s LinkedHashMap:

 HashMap LinkedHashMap
Uses hash table to store map entries (i.e.; key-value pairs) Uses combination of hash table + LinkedList to store map entries (i.e.; key-value pairs)
Doesn’t maintain insertion-order i.e.; while iterating through HashMap, we will get map entries in random-order Since, it uses doubly-linked list to store map entries (i.e.; key-value pairs), maintains insertion-order
This is introduced in the original collection framework in Java 1.2 version This is introduced in Java 1.4 version

When to use HashMap ?

  • HashMap stores key-value pairs which uses hashing technique to store key-value pairs
  • So, search operation is faster
  • So, if business requirement is to store key-value pairs for faster search operation or more number of search operation on the baisis of keys; without concerning insertion-order
  • Then, HashMap is the very apt choice

When to use LinkedHashMap ?

  • This is exactly same as that of HashMap, but underlying data structure to hold key-value pairs is different
  • It uses doubly-linked list which allows to hold key-value pairs as per insertion-order
  • So, if business requirement is to store key-value pairs for faster search operation or more number of search operation concerning/maintaining insertion-order
  • Then, LinkedHashSet is the very apt choice which maintains insertion-order
  • So while iterating through LinkedHashSet, we will get map entry (Key-Value pairs) as per insertion-order, as against random-order in HashMap

 

Map Program using HashMap and LinkedHashMap :

MapExample.java

package in.bench.resources.collection;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapExample {

	public static void main(String[] args) {

		// 1. Creating HashMap object
		Map<Integer, String> hashMap = 
				new HashMap<Integer, String>();

		// 1.1 add few entries
		hashMap.put(40, "RajKumarHirani");
		hashMap.put(50, "SanjayLeelaBanshali");
		hashMap.put(20, "Shankar");
		hashMap.put(10, "ManiRatnam");
		hashMap.put(30, "RajaMouli");

		// 1.2 get entrySet()
		Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();	

		System.out.println("Displaying HashMap entries"
				+ " in Random-order : \n");

		// 1.3 Iterate using enhanced for-Each loop
		for(Map.Entry<Integer, String> entry : entries) {
			System.out.println("Rank : " + entry.getKey() 
					+ "\t Director : " + entry.getValue());
		}

		// 2. Creating LinkedHashMap object
		Map<Integer, String> linkedHashMap = 
				new LinkedHashMap<Integer, String>();

		// 2.1 add few entries
		linkedHashMap.put(20, "Shankar");
		linkedHashMap.put(50, "SanjayLeelaBanshali");
		linkedHashMap.put(40, "RajKumarHirani");
		linkedHashMap.put(10, "ManiRatnam");
		linkedHashMap.put(30, "RajaMouli");


		// 2.2 get keySet()
		Set<Integer> keys = linkedHashMap.keySet();

		System.out.println("\nDisplaying LinkedHashMap entries"
				+ " as per Insertion-order : \n");

		// 2.3 Iterate using enhanced for-Each loop
		for(Integer rank : keys) {
			System.out.println("Rank : " + rank 
					+ "\t Director : " + linkedHashMap.get(rank));
		}
	}
}

Output:

Displaying HashMap entries in Random-order : 

Rank : 50	 Director : SanjayLeelaBanshali
Rank : 20	 Director : Shankar
Rank : 40	 Director : RajKumarHirani
Rank : 10	 Director : ManiRatnam
Rank : 30	 Director : RajaMouli

Displaying LinkedHashMap entries as per Insertion-order : 

Rank : 20	 Director : Shankar
Rank : 50	 Director : SanjayLeelaBanshali
Rank : 40	 Director : RajKumarHirani
Rank : 10	 Director : ManiRatnam
Rank : 30	 Director : RajaMouli

Explanation:

  • Sometime, iterating HashMap produces insertion-order but we can’t predict its actual order
  • Because on different run/execution it produces results in different order
  • That’s HashMap stores entries in random-order
  • Whereas LinkedHashMap stores entries as per insertion-order, as its underlying data-structure is doubly LinkedList

 

References:

 

Happy Coding !!
Happy Learning !!

IdentityHashMap class
LinkedHashMap class