LinkedHashMap Class in Java

Last Updated: 28 May, 2022

The LinkedHashMap class is a child class of HashMap. It was introduced in the Java 1.4 version and is available in the java.util package.

A LinkedHashMap is used to store the data in the form of key-value pairs. The implementation of LinkedHashMap is based on hash table and linked list.

LinkedHashMap maintains the insertion order of data.

👉 Important features of the LinkedHashMap

LinkedHashMap does not allow duplicate keys, but values may be duplicate.
LinkedHashMap allows only one null key and multiple null values.
LinkedHashMap is a non-synchronized class by default.
LinkedHashMap uses the hash table concept to store the data.
LinkedHashMap's initial capacity is 16, and its load factor is 0.75.

👉 LinkedHashMap Class Hierarchy

As we can see from the complete hierarchy above, LinkedHashMap extends the HashMap class and implements the Map interface.

👉 LinkedHashMap Class Desclaration

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

Here, K is the key Object type and V is the value Object type.

👉 Example: A sample Java program of LinkedHashMap

  
  import java.util.LinkedHashMap;
  import java.util.Map;
  public class LinkedHashMapExample {
    public static void main(String[] args) {
      // Creating LinkedHashMap
      LinkedHashMap<String, String> map = new LinkedHashMap<>();
      
      // Inserting data in the form of key-value pair using put() method
      map.put("in", "India");
      map.put("us", "United State");
      map.put("en", "England");
      map.put("ca", "Canada");
      
      System.out.println("Iterating LinkedHashMap and printing Key and Value");
      for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + " - " + m.getValue());
      }
    }
  }

Output

Iterating LinkedHashMap and printing Key and Value
in - India
us - United State
en - England
ca - Canada

👉 Constructors of Java LinkedHashMap Class

Constructor	Description
LinkedHashMap()	Constructs an empty insertion-ordered LinkedHashMap instance with the default initial capacity (16) and load factor (0.75).
LinkedHashMap(int initialCapacity)	Constructs an empty insertion-ordered LinkedHashMap instance with the specified initial capacity and a default load factor (0.75).
LinkedHashMap(int initialCapacity, float loadFactor)	Constructs an empty insertion-ordered LinkedHashMap instance with the specified initial capacity and load factor.
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)	Constructs an empty LinkedHashMap instance with the specified initial capacity, load factor and ordering mode.
LinkedHashMap(Map<? extends K,? extends V> m)	Constructs an insertion-ordered LinkedHashMap instance with the same mappings as the specified map.

👉 Java LinkedHashMap Class Methods

The LinkedHashMap class in java has the following methods.

Methods with Description
public boolean containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
public V get(Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) Returns true if this map should remove its eldest entry.
public Set<K> keySet() Returns a Set view of the keys contained in this map.
public Collection<V> values() Returns a Collection view of the values contained in this map.
public Set<Map.Entry<K,V>> entrySet() Returns a Set view of the mappings contained in this map.

LinkedHashMap Class Methods Examples

The Java LinkedHashMap class provided methods are implemented in the below given examples. Let's go through the examples one by one and understand the uses for each method.

Example 1 : Methods for Adding elements in LinkedHashMap

  
  import java.util.LinkedHashMap;
  public class AddElementsInLinkedHashMap {
    public static void main(String args[]) {
  
      // Creating LinkedHashMap
      LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
      map.put(101, "C");
      map.put(102, "C++");
      map.put(103, "Java");
      map.put(104, "Python");
  
      System.out.println("LinkedHashMap Elements: " + map);
  
      // Add element if Key is unique
      map.putIfAbsent(105, "Go Lang");
      // Adding duplicate Key
      map.putIfAbsent(104, "HTML");
      System.out.println("\nAfter calling putIfAbsent(): " + map);
  
      // Creating another LinkedHashMap
      LinkedHashMap<Integer, String> childMap = new LinkedHashMap<>();
      childMap.put(111, "MySQL");
      childMap.put(112, "MongoDB");
  
      // Copies all of the mappings from the specified map to this map
      map.putAll(childMap);
  
      System.out.println("\nLinkedHashMap Elements after adding another LinkedHashMap:");
      System.out.println(map);
    }
  }

Output

LinkedHashMap Elements:{101=C, 102=C++, 103=Java, 104=Python}

After calling putIfAbsent():{101=C, 102=C++, 103=Java, 104=Python, 105=Go Lang}

LinkedHashMap Elements after adding another LinkedHashMap:

{101=C, 102=C++, 103=Java, 104=Python, 105=Go Lang, 111=MySQL, 112=MongoDB}

Example 2 : Methods for Accessing elements from LinkedHashMap

  
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.Map;
  public class AccessElementsFromLinkedHashMap {
    public static void main(String args[]) {
  
      // Creating LinkedHashMap
      LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
      map.put(101, "C");
      map.put(102, "C++");
      map.put(103, "Java");
      map.put(104, "Python");
      map.put(105, "Go Lang");
  
      System.out.println("LinkedHashMap Elements: " + map);
  
      // Iterate the map using for-each loop
      System.out.println("\nIterate the map using for-each loop");
        for (Map.Entry<Integer, String> e : map.entrySet())
            System.out.println("Key: " + e.getKey() + " Value: " + e.getValue());
        
        // Access element by key
        System.out.println("\nAfter called map.get(102): " + map.get(102));
        
        // Returns a Collection view of the values contained in this map.
        System.out.println("\nReturns a Collection view of the values contained in this map");
        Collection<String> values = map.values();
        for(String str : values)
          System.out.println(str);
    }
  }

Output

LinkedHashMap Elements:{101=C, 102=C++, 103=Java, 104=Python, 105=Go Lang}

Iterate the map using for-each loop
Key: 101 Value: C
Key: 102 Value: C++
Key: 103 Value: Java
Key: 104 Value: Python
Key: 105 Value: Go Lang

After called map.get(102): C++

Returns a Collection view of the values contained in this map C
C++
Java
Python
Go Lang

Example 3 : Methods for Updating elements in LinkedHashMap

  
  import java.util.HashMap;
  public class UpdateElementsInLinkedHashMap {
    public static void main(String args[]) {
  
      // Creating HashMap
      HashMap<Integer, String> map = new HashMap<>();
      map.put(101, "C");
      map.put(102, "C++");
      map.put(103, "Java");
      map.put(104, "Python");
      map.put(105, "Go Lang");
  
      System.out.println("HashMap Elements: " + map);
  
      // Replaces the entry for the specified key
      map.replace(105, "MySQL");
      System.out.println("\nAfter called map.replace(105, \"MySQL\"):");
      System.out.println(map);
      
      // Replaces the entry for the specified key and value
      map.replace(103, "Java", "JAVA/J2EE");
      System.out.println("\nAfter called map.replace(103, \"Java\", \"JAVA/J2EE\"):");
      System.out.println(map);
      
      // Replace all the values
        map.replaceAll((k,v) -> "MongoDB");
        System.out.println("\nAfter called map.replaceAll((k,v) -> \"MongoDB\"):");
        System.out.println(map);
    }
  }

Output

HashMap Elements:{101=C, 102=C++, 103=Java, 104=Python, 105=Go Lang}

After called map.replace(105, "MySQL"):
{101=C, 102=C++, 103=Java, 104=Python, 105=MySQL}

After called map.replace(103, "Java", "JAVA/J2EE"):
{101=C, 102=C++, 103=JAVA/J2EE, 104=Python, 105=MySQL}

After called map.replaceAll((k,v) -> "MongoDB"):
{101=MongoDB, 102=MongoDB, 103=MongoDB, 104=MongoDB, 105=MongoDB}

Example 4 : Methods for Removing elements from LinkedHashMap

  
  import java.util.LinkedHashMap;
  public class RemoveElementsFromLinkedHashMap {
    public static void main(String args[]) {
  
      // Creating LinkedHashMap
      LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
      map.put(101, "C");
      map.put(102, "C++");
      map.put(103, "Java");
      map.put(104, "Python");
      map.put(105, "Go Lang");
  
      System.out.println("LinkedHashMap Elements: " + map);
  
      // Remove element by key
      map.remove(102);
      System.out.println("\nAfter called map.remove(102): " + map);
  
      // Remove element by key-value
      map.remove(104, "Python");
      System.out.println("\nAfte called map.remove(104, \"Python\"):");
      System.out.println(map);
  
      // Remove element by correct key and wrong value.
      map.remove(101, "C++");
      System.out.println("\nAfter called map.remove(101, \"C++\"):");
      System.out.println(map);
  
      // Remove all the elements
      map.clear();
      System.out.println("\nAfter called map.clear(): " + map);
    }
  }

Output

LinkedHashMap Elements:{101=C, 102=C++, 103=Java, 104=Python, 105=Go Lang}

After called map.remove(102):{101=C, 103=Java, 104=Python, 105=Go Lang}

Afte called map.remove(104, "Python"):
{101=C, 103=Java, 105=Go Lang}

After called map.remove(101, "C++"):
{101=C, 103=Java, 105=Go Lang}

After called map.clear():{}

Example 5 : Utility methods of LinkedHashMap

  
  import java.util.LinkedHashMap;
  public class LinkedHashMapUtilityMethods {
    public static void main(String args[]) {
  
      // Creating LinkedHashMap
      LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
      map.put(101, "C");
      map.put(102, "C++");
      map.put(103, "Java");
      map.put(104, "Python");
  
      System.out.println("LinkedHashMap Elements: " + map);
  
      // Returns the number of key-value mappings in this map.
      System.out.println("LinkedHashMap Size: " + map.size());
      
      // Returns true if this map contains no key-value mappings.
      System.out.println("Is Map is Empty: " + map.isEmpty());
      
      // Returns true if this map contains a mapping for the specified key.
      System.out.println("map.containsKey(105): " + map.containsKey(105));
      
      // Returns true if this map maps one or more keys to the specified value.
      System.out.println("map.containsValue(\"Java\"): " + map.containsValue("Java"));
      
      // Remove all the elements from the map
      map.clear();
      System.out.println("After calling map.clear(): " + map);
    }
  }

Output

LinkedHashMap Elements:{101=C, 102=C++, 103=Java, 104=Python}
LinkedHashMap Size: 4
Is Map is Empty: false
map.containsKey(105): false
map.containsValue("Java"): true
After calling map.clear():{}

Reference: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedHashMap

HashMap	LinkedHashMap
HashMap extends the AbstractMap class.	LinkedHashMap extends the HashMap class.
HashMap does not maintain the insertion order of elements.	The insertion order of elements is preserved by LinkedHashMap. (Major Difference)
HashMap uses hash tables to store maps.	LinkedHashMap uses a hash table along with a linked list to store maps.
HashMap was introduced in the JDK 1.2 version.	LinkedHashMap was introduced in the JDK 1.4 version.
HashMap required less memory than LinkedHashMap.	LinkedHashMap required more memory than LinkedHashMap.
HashMap gives faster performance than LinkedHashMap.	LinkedHashMap's performance is a bit slower than HashMap's.

LinkedHashMap Class in Java

👉 Important features of the LinkedHashMap

👉 LinkedHashMap Class Hierarchy

👉 LinkedHashMap Class Desclaration

👉 Example: A sample Java program of LinkedHashMap

👉 Constructors of Java LinkedHashMap Class

👉 Java LinkedHashMap Class Methods

LinkedHashMap Class Methods Examples

LinkedHashMap - Interview Questions and Answers

Currently No Video available