1. Introduction
In this tutorial, We'll learn LinkedHashMap API in java with example programs.
LinkedHashMap is used to store the key-value pairs as similar to the HashMap. But, LinkedHashMap extends HashMap and AbstractMap implements Map interface. The main advantage of LinkedHashMap is it preserves the insertion order that meanwhile iterating it pull the Entry Objects how the order keys are inserted into LinkedHashMap.Iterating over collection in java
We have discussed HashMap in-depth with all methods examples including java 8 concepts. It is good to go over the HashMap article that makes you answer interview questions on all of its methods.
If you do not understand at any point just leave your question in comments.
2. LinkedHashMap Key Features
Below are the key factors of LinkedHashMap.
- LinkedHashMap stores the key value pairs.
- LinkedHashMap uses the internally Double LinkedList.
- LinkedHashMap preserves the insertion order and this order is done using Linked List which holds the address of the next Entry object.
- LinkedHashMap does not allow duplicate keys
- LinkedHashMap allows only one null key and allows multiple null values.
- LinkedHashMap is not synchronized
- LinkedHashMap has all features of HashMap except holding the insertion order.
3. Internals
3.1 Hierarchy
Below are the classes and interfaces that are involved in implementation.java.lang.Object
java.util.AbstractMap<K,V>
java.util.HashMap<K,V>
java.util.LinkedHashMap<K,V>
3.2 Class declaration:
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
3.3 Entry class
Below is the Entry class implementation and it is extending HashMap.Node class. It has two references for Entry type those are to hold before and after entry refs. If a key/value is added to the map and immediately it will be added with before and after entry object references.
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
4. Creating LinkedHashMap Objects
LinkedHashMap has 5 constructors to create its object.
Way 1: Creates an empty map with size 16.
Way 2: With an initial capacity
Way 3: Creating from an existing map
Way 4: With the size and load factor
Way 5: With size, load factor and access order. true for accessing order and false for insertion order.
// creating LinkedHashMap way
LinkedHashMap<Integer, String> way1 = new LinkedHashMap<>();
// way 2
LinkedHashMap<Integer, String> way2 = new LinkedHashMap<>(25);
// way 3
LinkedHashMap<Integer, String> way3 = new LinkedHashMap<>(way2);
// way 4
LinkedHashMap<Integer, String> way4 = new LinkedHashMap<>(50, 0.5f);
// way 5
LinkedHashMap<Integer, String> way5 = new LinkedHashMap<>(75, 0.75f, false);
5. LinkedHashMap Methods
This gets all methods of the HashMap but the below are directly from LinkedHashMap.
- clear(): Removes all of the mappings from this map.
- containsValue(Object value): Returns boolean value true if the specified value is present in the map else returns false.
- entrySet(): Returns a Set of Entry<K, V> objects. Returned Set is tightly linked to the underlying map. If the Map is modified then the returned Set will be reflected with modifications.
- forEach(BiConsumer biconsumer): Executes the BiConsumer logic to each key-value pair in the map.
- get(Object key): Returns the value for the specified key. Returns null if the key is not present in the map.
- getOrDefault(Object key, V defaultValue): Returns the value for the specified key. If key does not exits then return the default value that we have passed.
- keySet(): Returns all keys in the form of Set.
- removeEldestEntry(Map.Entry<K,V> eldest): Returns true if this map should remove its eldest entry
- replaceAll(BiFunction function): BiFunction logic is executed for all keys and returned value will be updated as a new value in the map for each key.
- values(): Returns all values as Collection
You may get a question
why only the above methods are implemented as part of LinkedHashMap instead of using from HashMap class?
Answer: As mentioned earlier, This class holds pointers as below. If any methods that are needed to interact with these set of pointers those methods are added as part of LinkedHashMap.transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
Entry<K,V> before, after;
final boolean accessOrder;
6. LinkedHashMap All Methods Example
Below is the example program for all methods.package com.java.w3schools.blog.linkedhashmap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class LinkedHashMapExample {
public static void main(String[] args) {
// creating LinkedHashMap way
LinkedHashMap<Integer, String> way1 = new LinkedHashMap<>();
// way 2
LinkedHashMap<Integer, String> way2 = new LinkedHashMap<>(25);
// way 3
LinkedHashMap<Integer, String> way3 = new LinkedHashMap<>(way2);
// way 4
LinkedHashMap<Integer, String> way4 = new LinkedHashMap<>(50, 0.5f);
// way 5
LinkedHashMap<Integer, String> way5 = new LinkedHashMap<>(75, 0.75f, false);
// Adding values to LinkedHashMap
System.out.println("\nput example");
way5.put(111, "One");
way5.put(222, "Two");
way5.put(333, "Three");
way5.put(444, "Four");
way5.put(555, "Five");
String value111 = way5.get(111);
System.out.println("value of key 111 : " + value111);
// getOrDefault example
System.out.println("\ngetOrDefault example");
String valueDefault = way5.getOrDefault(5000, "No Key Found");
System.out.println("get default value : " + valueDefault);
String value333 = way5.compute(333, (k, v) -> (v + " - " + k));
System.out.println("compute example : " + value333);
// containsKey example
System.out.println("\ncontainsKey example");
boolean key555Present = way5.containsKey(555);
System.out.println("555 key present : " + key555Present);
// forEach example
System.out.println("\nforEach example");
way5.forEach((key, value) -> System.out.println("key - " + key + ", Value - " + value));
// containsValue example
System.out.println("\ncontainsValue example");
System.out.println(way5.containsValue("Five"));
// entrySet example
System.out.println("\nentrySet example");
Set<Entry<Integer, String>> s = way5.entrySet();
Iterator<Entry<Integer, String>> it = s.iterator();
while (it.hasNext()) {
Entry<Integer, String> e = it.next();
System.out.println(e.getKey() + " ---- " + e.getValue());
}
// keySet example
System.out.println("\nkeySet example");
Set<Integer> keySet = way5.keySet();
Iterator<Integer> keyIterator = keySet.iterator();
while (keyIterator.hasNext()) {
System.out.println(keyIterator.next());
}
// replaceAll example
System.out.println("\n replaceAll example");
way5.replaceAll((k, v) -> (k + v));
System.out.println(way5);
// clear() example
way5.clear();
System.out.println(way5.size());
}
}
Output:
put example
value of key 111 : One
getOrDefault example
get default value : No Key Found
compute example : Three - 333
containsKey example
555 key present : true
forEach example
key - 111, Value - One
key - 222, Value - Two
key - 333, Value - Three - 333
key - 444, Value - Four
key - 555, Value - Five
containsValue example
true
entrySet example
111 ---- One
222 ---- Two
333 ---- Three - 333
444 ---- Four
555 ---- Five
keySet example
111
222
333
444
555
replaceAll example
{111=111One, 222=222Two, 333=333Three - 333, 444=444Four, 555=555Five}
0
7. Conclusion
In this article, We've seen What is LinkedHashMap API and What is the importance. When we should use this? Shown example programs for all its methods.
If you want to store a key-value pairs and insertion order needs to be preserved then we should go with this. This is similar to the HashMap except it holds the order of insertion.
GitHub
Ref API
0 Comments