LinkedHashMap class

In this article, we will discuss LinkedHashMap class – one of the Map implemented classes in detail

LinkedHashMap is exactly same as that of HashMap but preserving insertion order



  • LinkedHashMap is implementation class of Map interface (i.e.; LinkedHashMap implements Map)
  • This is introduced in Java 1.4 version
  • LinkedHashMap uses combination of LinkedList & hash table to store Map entries (i.e.; key-value pairs)
  • LinkedHashMap allows only unique keys but there is no restriction on values which can be duplicated
  • At any time, LinkedHashMap contains only unique keys
  • Insertion order is maintained
  • While iterating through LinkedHashMap, we will get map entries as per insertion order
  • Allows NULL insertion for key but maximum of only one
  • Also, allows NULL insertion for values without any upper limit i.e.; we can insert null value against any unique key
  • Without generics, LinkedHashMap allows to insert any type of key and values; with generics, it is type-bounded (except, if we take both key-value as Objects within angle brackets)
  • LinkedHashMap is non-synchronized
  • Present in java.util package and extends java.util.HashMap implements java.util.Map interface
  • Also, implements java.lang.Cloneable, marker interfaces which provides special ability to LinkedHashMap (provided by JVM at run time)

Cloneable: to create a duplicate object or to clone an object

Serializable: to transfer objects across network


Source: Team BenchResources.Net


LinkedHashMap constructors:

LinkedHashMap hs = new LinkedHashMap();

  • creates an empty LinkedHashMap object of size 16 with default fill ratio 0.75


LinkedHashMap hs = new LinkedHashMap(int initialCapacity);

  • creates an empty LinkedHashMap object of specified size (or initial capacity) with default fill ratio 0.75


LinkedHashMap hs = new LinkedHashMap(int initialCapacity, float loadFactor);

  • creates an empty LinkedHashMap object of specified size (or initial capacity) and specified fill ratio (for example 0.85)


LinkedHashMap hs = new LinkedHashMap(Collection c);

  • created an equivalent LinkedHashMap object for the specified collection
  • it is basically used for inter-conversion between collection objects


LinkedHashMap hs = new LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder);

  • creates an empty LinkedHashMap object of specified size (or initial capacity) and specified fill ratio (for example 0.85) and specified ordering mode
  • like true for access order and false for insertion order


Fill ratio (or Load factor)

  • Fill ratio is also known as Load factor
  • This factor determines when to increase the size of LinkedHashMap automatically
  • For example, for the 1st two constructors the default load factor is 75 à which means after filling 75 % of LinkedHashMap, new LinkedHashMap of bigger size will be created
  • For 3rd constructor, programmer can define load factor while creating LinkedHashMap object. If programmer define it to be 0.95, then after filling 95% of LinkedHashMap, size of LinkedHashMap will be increased automatically
  • The value of Load factor should be in between 0 to 1.0


LinkedHashMap examples:


import java.util.LinkedHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class LinkedHashMapAddAndRemove {

	public static void main(String[] args) {

		// creating LinkedHashMap object of type <Integer, String>
		LinkedHashMap<Integer, String> lhm = 
				new LinkedHashMap<Integer, String>();

		// adding key-value pairs to LinkedHashMap object
		lhm.put(1, "Google");
		lhm.put(2, "Facebook");
		lhm.put(3, "Yahoo");
		lhm.put(4, "Amazon");
		lhm.put(5, "Reddit");

		System.out.println("Printing all key-value pairs inside {}\n"
				+ lhm + "\n");

		System.out.println("\nIterating using keySet\n");

		// Iterating key-pairs using keySet
		Set<Integer> keys = lhm.keySet();
		for(Integer key : keys) {
			System.out.println(key + "  " + lhm.get(key));

		System.out.println("\n\nIterating using Map Entry interface\n");

		// Iterating key-pairs using Map entry
		Set set = lhm.entrySet();
		Iterator iterator = set.iterator();

		while(iterator.hasNext()) {

			Map.Entry mapEntry = (Map.Entry);
			System.out.println(mapEntry.getKey() + "  "
					+ mapEntry.getValue());

		// removing map entry at 4th position
		System.out.println("\n\nEntry removed at 4th position : "
				+ lhm.remove(4));


Printing all key-value pairs inside {}
{1=Google, 2=Facebook, 3=Yahoo, 4=Amazon, 5=Reddit}

Iterating using keySet

1  Google
2  Facebook
3  Yahoo
4  Amazon
5  Reddit

Iterating using Map Entry interface

1  Google
2  Facebook
3  Yahoo
4  Amazon
5  Reddit

Entry removed at 4th position : Amazon


Difference between HashMap and LinkedHashMap?

The main difference between HashMap and LinkedHashMap is insertion order.

HashMap doesn’t maintain insertion order and print values in random order while iterating, whereas LinkedHashMap maintains insertion order as seen in above example


Note: All methods of LinkedHashMap is non-synchronized but it can be easily converted into synchronized LinkedHashMap using utility method of java.util.Collections class

Map map = Collections.synchronizedMap(lhm);





Happy Coding !!
Happy Learning !!

HashMap vs LinkedHashMap
HashMap class