Elements returned from the HashMap while iterating over it might not be in the same order they were inserted. That is because HashMap does not guarantee to maintain the insertion order of the elements. As per the HashMap Java Doc:
This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.
How to maintain the insertion order of the elements in Java HashMap?
We cannot. The HashMap class does not maintain the order of the elements. This means that It might not return the elements in the same order they were inserted into it. If the application needs the elements to be returned in the same order they were inserted, LinkedHashMap should be used.
The LinkedHashMap class implements a doubly linked list so that it can traverse through all the elements. As per LinkedHashMap Java Doc:
This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).
In the scenario wherein the HashMap is returned from the third-party library which cannot be changed and application needs ordering of the elements contained in it, a LinkedHashMap object can be created from the HashMap object. The LinkedHashMap class has a special constructor for that purpose which takes a Map as an argument.
|
1 |
public LinkedHashMap(Map m) |
The above given constructor creates an object of the LinkedHashMap class with the same mappings specified in the original Map object.
Important Note:
The LinkedHashMap object created in this way maintains the insertion order in which the elements were returned from the HashMap while the creation of it (and not the order in which elements were inserted into original HashMap). Let’s see a small example to demonstrate that.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
package com.javacodeexamples.collectionexamples; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; public class HashMapOrderExample { public static void main(String args[]){ HashMap<string, employee=""> employeeMap = new HashMap<string, employee="">(); employeeMap.put("emp01", new Employee("emp01", "Jason", "IT")); employeeMap.put("emp03", new Employee("emp03", "Aaron", "Supply Chain")); employeeMap.put("emp04", new Employee("emp04", "Oliver", "Marketing")); employeeMap.put("emp02", new Employee("emp02", "Raj", "IT")); System.out.println("Iterate over original HashMap"); for(Map.Entry<string, employee=""> entry : employeeMap.entrySet()){ System.out.println(entry.getKey() + " => " + ": " + entry.getValue()); } //convert HashMap to LinkedHashMap LinkedHashMap<string, employee=""> employeeLinkedHashMap = new LinkedHashMap<string, employee="">(employeeMap); System.out.println(""); System.out.println("Iterate over LinkedHashMap"); for(Map.Entry<string, employee=""> entry : employeeLinkedHashMap.entrySet()){ System.out.println(entry.getKey() + " => " + ": " + entry.getValue()); } } } |
Output
|
1 2 3 4 5 6 7 8 9 10 11 |
Iterate over original HashMap emp01 => : [emp01 : Jason : IT] emp03 => : [emp03 : Aaron : Supply Chain] emp02 => : [emp02 : Raj : IT] emp04 => : [emp04 : Oliver : Marketing] Iterate over LinkedHashMap emp01 => : [emp01 : Jason : IT] emp03 => : [emp03 : Aaron : Supply Chain] emp02 => : [emp02 : Raj : IT] emp04 => : [emp04 : Oliver : Marketing] |
As you can see, we have inserted the Employee objects in HashMap in [emp01, emp03, emp04, emp02] order. However, when we printed the elements by iterating over HashMap, the order was changed to [emp01, emp03, emp02, emp04]. It did not maintain the original insertion order of the elements “emp02” and “emp04”.
Then we created a LinkedHashMap object from the original HashMap object and printed it. Which returned the elements in [emp01, emp03, emp02, emp04] order. This is the order in which HashMap returned the elements when LinkedHashMap was created from it. From that point onwards, LinkedHashMap will keep this insertion order whenever it returns the element (not the original order [emp01, emp03, emp02, emp04]).
Here is the example Employee class used in this example.
This example is a part of the Java Hashmap tutorial.
Please let me know your views in the comments section.
About the author
- Gson – Serialize HashMap null entries - April 5, 2023
- Gson: Convert String to JsonObject without POJO - April 5, 2023
- Gson – Convert JSON to a Typed ArrayList - April 5, 2023
