Updated April 15, 2023
Introduction to Java LinkedHashMap
In Java, LinkedHashMap is an implementation of linkedlist from the interface Map. It is similar to HashMap, where an extra feature is included that maintains the order of elements that are being inserted into it. Even though HashMap provides quick insertion, deletion, and search, element insertion order is not maintained.
Features of Java LinkedHashMap
In addition to that, several other features are also included in LinkedHashMap.
- It consists of unique elements only.
- It can contain a single null key and several null values.
- Insertion order is maintained.
- Extends HashMap class.
- Values present are based on the key.
- Non synchronized.
- 16 is the initial default capacity
- The load factor is 0.75.
Syntax:
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();Here, obj is the object of the created LinkedHashMap.
Once the LinkedHashMap object is created, it will be used for adding elements to the map, as shown below.
obj.put(11, "Victor");
obj.put(33, "Shyla");
obj.put(14, "Nancy");
obj.put(100, "Kuffi");
obj.put(23, "Princy");
obj.put(37, "Chamm");Constructors
Given below are the constructors of a LinkedHashMap:
1. LinkedHashMap(): An empty LinkedHashMap instance will be created with the ordering based on insertion, load factor 0.75 and default initial capacity as 16.
2. LinkedHashMap(int initialCapacity): An empty LinkedHashMap instance will be created with the ordering based on insertion, load factor 0.75 and specified initial capacity.
3. LinkedHashMap(int initialCapacity, float loadFactor): An empty LinkedHashMap instance will be created with the ordering based on insertion, specified load factor, and initial capacity.
4. LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder): An empty LinkedHashMap instance will be created with specified load factor, access order and initial capacity.
5. LinkedHashMap(Map<? extends K,? extends V> m): A LinkedHashMap instance will be created with the ordering based on insertion and mappings based on the mentioned map.
Methods
The following are the commonly used methods in LinkedHashMap.
1. clear(): Every mapping from the map will be removed.
2. boolean containsKey(Object key): If the map contains a mapping to one or more than one key of the value mentioned, true will be returned.
3. boolean containsValue(Object key): If the map contains a mapping to a minimum of one key, true will be returned.
4. Object get(Object key): The value of the mentioned key’s mapping will be returned.
5. isEmpty(): If there are no key-value pair mappings, true will be returned.
6. size(): Count of key-value pairs available in the map will be returned.
7. Object remove(Object key): The value of the mentioned key’s mapping will be removed.
8. boolean removeEldestEntry(Map.Entry eldest): If the eldest entry can be removed, true will be returned.
Examples of Java LinkedHashMap
Given below are the examples of Java LinkedHashMap:
Example #1
Java program to create a simple LinkedHashMap.
Code:
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();
//Adding key-value pair 1
obj.put(11, "Anna");
//Adding key-value pair 2
obj.put(33, "Adam");
//Adding key-value pair 3
obj.put(14, "Iza");
//Adding key-value pair 4
obj.put(23, "Norah");
//Adding key-value pair 5
obj.put(100, "Denan");
// create an entry set
Set s = obj.entrySet();
// Display the elements
Iterator itr = s.iterator();
//iterate each element
while(itr.hasNext()) {
//create an object for map.entry
Map.Entry mp = (Map.Entry)itr.next();
//print each element
System.out.print("Key in the LinkedHashMap is : "+ mp.getKey() +
" and it's corresponding value is: "+mp.getValue()+" \n");
}
}
}Output:
In this program, a LinkedHashMap is created first. After that, elements are added to it with key-value pairs. Once it is completed, an entry set is created. Moreover, in order to print all the elements in the LinkedHashMap, an iterator is created. By iterating each element, it is printed and displayed as shown in the sample output.
Example #2
Java program to remove key-value pair from the map.
Code:
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();
//Adding key-value pair 1
obj.put(11, "Victor");
//Adding key-value pair 2
obj.put(33, "Shyla");
//Adding key-value pair 3
obj.put(14, "Nancy");
//Adding key-value pair 4
obj.put(100, "Kuffi");
//Adding key-value pair 5
obj.put(23, "Princy");
//Adding key-value pair 6
obj.put(37, "Chamm");
System.out.print("Before removal, LinkedHashMap is: "+obj+"\n");
//remove the elements with keys 100 and 37
obj.remove(100);
obj.remove(37);
System.out.print("After removal, LinkedHashMap is: "+obj);
}
}Output:
In this program, also, a LinkedHashMap is created first. After that, elements are added to it with key-value pairs. Once it is completed, LinkedHashMap is printed. Then, two key-value pairs are removed from the map using the method remove(). After that, once again, the map is printed and displayed as shown in the sample output.
Example #3
Java program to print key-value pairs in the map on the basis of access order.
Code:
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap with third paramter set access order
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>(2, .75f, true);
//Adding key-value pair 1
obj.put(11, "Victor");
//Adding key-value pair 2
obj.put(33, "Shyla");
//Adding key-value pair 3
obj.put(14, "Nancy");
//Adding key-value pair 4
obj.put(100, "Kuffi");
//Adding key-value pair 5
obj.put(23, "Princy");
//Adding key-value pair 6
obj.put(37, "Chamm");
//Access the pair 33
obj.get(33);
//Access the pair 11
obj.get(11);
System.out.print("LinkedHashMap with access order is: "+obj);
}
}Output:
Here, in this program also, a LinkedHashMap is created first. After that, elements are added to it with key-value pairs. Once it is completed, the elements with keys 33 and 11 are accessed. Then, the map is printed and displayed as shown in the sample output. It can be seen that the elements that are accessed are at the end of the map.
Conclusion
Almost all details on Java LinkedHashMap, such as syntax, constructors, methods, and examples, are explored in this article in detail. Moreover, it also identifies the main difference between LinkedHashMap and HashMap.
Recommended Articles
This is a guide to Java LinkedHashMap. Here we discuss the introduction, constructors, methods, and examples. You may also have a look at the following articles to learn more –
