Java LinkedHashMap tutorial with examples will help you understand how to use Java LinkedHashMap in an easy way. The LinkedHashMap in Java is an implementation of a hashtable and linked list of the Map interface. Unlike HashMap, LinkedHashMap maintains the order of its elements. That means it returns the elements in the same order they were inserted.
Another difference between HashMap and LinkedHashMap is that internally the LinkedHashMap class maintains a doubly linked list to link all of its elements and guarantees to maintain the insertion order of the elements. Plus reinserting the same key into the LinkedHashMap object does not change the element’s order.
Like HashMap, LinkedHashMap class in Java provides all Map operations and allows null elements. The LinkedHashMap class provides constant time performance for the basic operations like add, remove and contains.
LinkedHashMap in Java is not a synchronized implementation. That means if multiple threads are simultaneously accessing the LinkedHashMap and modifying it, the code must handle the synchronization explicitly. You can get a synchronized map instance from the LinkedHashMap object using the synchronizedMap method of the Collections class as given below.
|
1 |
Map<String, String> synchronizedMap = Collections.synchronizedMap(new LinkedHashMap<String, String>()); |
You can also use the existing LinkedHashMap object instead of creating a new one.
How to create LinkedHashMap objects?
The LinkedHashMap class in Java provides several constructors to create new objects. The default no-argument constructor creates a new and empty LinkedHashMap object.
|
1 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); |
If you want to convert an existing map object like HashMap to LinkedHashMap, you can use the below given constructor which accepts a map object. This constructor creates a new LinkedHashMap object having the same key-value mappings as the specified map object.
|
1 |
LinkedHashMap linkedMap = new LinkedHashMap(existingHashMapObject); |
There is also a special LinkedHashMap constructor which creates a new LinkedHashMap object that returns the elements in the order they were last accessed. To create such a LinkedHashMap object, you can use below given constructor.
|
1 |
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) |
This kind of map object is particularly useful to create a cache of the frequently accessed data.
LinkedHashMap Methods
Below given are some of the most important LinkedHashMap methods.
How to add key value mappings to the LinkedHashMap object using the put, putAll, and putIfAbsent methods?
The put method of the LinkedHashMap class adds a key-value mapping to the LinkedHashMap object. If the key exists, the previous value associated with the key is replaced by the specified new value the old value is returned. This method returns null if the specified key does not exist in the map or the key was associated with a null value.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); /* * Add key-value pairs to LinkedHashMap using * put method. */ lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); System.out.println(lhMapNumbers); /* * If key already exists, the old value * mapped to the key will be replaced * by the specified value for the key */ lhMapNumbers.put("2", "Five"); System.out.println(lhMapNumbers); |
Output
|
1 2 |
{1=One, 2=Two, 3=Three} {1=One, 2=Five, 3=Three} |
If you do not want to replace the value if the key already exists in the map, use the putIfAbsent method instead of the put method. The putIfAbsent method adds key-value mapping if and only if the key does not exist in the map or the key is associated with a null value.
|
1 |
public V putIfAbsent(K key, V value) |
If the key does not exist in the map or it is mapped to a null value, this method creates an association of the key with the given value and returns null. If the key already exists in the map, it returns a value associated with the key.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
LinkedHashMap<Integer, String> lhMapNumbers = new LinkedHashMap<Integer, String>(); lhMapNumbers.put(1, "One"); lhMapNumbers.put(2, null); lhMapNumbers.put(3, "Three"); /* * This will create 4=>Four mapping as the key * 4 does not exist in the map, and returns null */ System.out.println( lhMapNumbers.putIfAbsent(4, "Four") ); /* * This will create mapping 2=>Two as the key 2 is * currently associated with a null value, and returns null. */ System.out.println( lhMapNumbers.putIfAbsent(2, "Two") ); /* * This will do nothing and return "One" because key 1 * is associated with the value "One" */ System.out.println( lhMapNumbers.putIfAbsent(1, "NewOne") ); System.out.println("LinkedHashMap contains: " + lhMapNumbers); |
Output
|
1 2 3 4 |
null null One LinkedHashMap contains: {1=One, 2=Two, 3=Three, 4=Four} |
The putAll method of the LinkedHashMap class adds all the key-value mappings of the specified map to this map object. Values with the matching keys will be replaced with the values contained in the specified map.
The below given example shows how to copy all mappings of HashMap to LinkedHashMap using the putAll method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "one"); lhMapNumbers.put("2", "two"); lhMapNumbers.put("3", "three"); HashMap<String, String> hashMap = new HashMap<String, String>(); hashMap.put("3", "THREE"); hashMap.put("4", "FOUR"); hashMap.put("5", "FIVE"); /* * To copy all the mappings of other map like HashMap to LinkedHashMap, * use the putAll method. */ //copy hashmap to linkedhashmap lhMapNumbers.putAll(hashMap); System.out.println("LinkedHashMap contains: " + lhMapNumbers); |
Output
|
1 |
LinkedHashMap contains: {1=one, 2=two, 3=THREE, 4=FOUR, 5=FIVE} |
As you can see from the output, the value for key “3” in LinkedHashMap is replaced by the value of the key “3” of the HashMap object.
How to get value mapped to a key from LinkedHashMap using the get and getOrDefault methods?
The get method of LinkedHashMap class returns the value associated with the given key. If there is no value associated with the given key, it returns null.
|
1 2 3 4 5 6 7 8 9 10 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //this will return One System.out.println( lhMapNumbers.get("1") ); //this will return null System.out.println( lhMapNumbers.get("5") ); |
Output
|
1 2 |
One null |
The getOrDefault method is similar to the get method. It returns a value associated with the given key if the key exists. However, if the key is not mapped to any value, this method returns the specified default value.
|
1 2 3 4 5 6 7 8 9 10 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //this will print Two, because map cotains key 2 System.out.println( lhMapNumbers.getOrDefault("2", "NoMapping") ); //this will print NoMapping, because map does not contain key 5 System.out.println( lhMapNumbers.getOrDefault("5", "NoMapping") ); |
Output
|
1 2 |
Two NoMapping |
How to remove key value mappings from LinkedHashMap using the remove method?
The remove method of the LinkedHashMap class removes a key-value pair for the given key. It returns the value associated with the key or null if the mapping does not exist for the given key. Remember, the remove method may also return null if the specified key was associated with the null value.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); /* * Use remove method to remove a * key-value pair from LinkedHashMap for * a given key. */ //this will return Two System.out.println( lhMapNumbers.remove("2") ); //this will return null System.out.println( lhMapNumbers.remove("5") ); System.out.println("Pairs: " + lhMapNumbers); |
Output
|
1 2 3 |
Two null Pairs: {1=One, 3=Three} |
Use an overloaded remove method if you want to delete a mapping for a given key only if it associated with the specified value. It returns true if the key value mapping is removed from the map, false otherwise.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //the mapping for key "2" will be removed as "2" is mapped to "Two", will return true System.out.println( lhMapNumbers.remove("2", "Two") ); //the mapping will not be removed as 3 is not associated with "Five", will return false System.out.println( lhMapNumbers.remove("3", "Five") ); System.out.println("Mappings: " + lhMapNumbers); |
Output
|
1 2 3 |
true false Mappings: {1=One, 3=Three} |
How to remove all mappings from LinkedHashMap object using the clear method?
Use clear method of the LinkedHashMap class to remove all mappings from it. The LinkedHashMap object becomes empty after this method call.
|
1 2 3 4 5 6 7 8 9 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //remove all mappings from LinkedHashMap object lhMapNumbers.clear(); System.out.println("Mappings: " + lhMapNumbers); |
Output
|
1 |
Mappings: {} |
How to get the size of the LinkedHashMap object using the size method? (LinkedHashMap length)
The size method of the LinkedHashMap class returns the number of mappings stored in the map. It returns 0 if the LinkedHashMap is empty.
|
1 2 3 4 5 6 7 8 9 10 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); System.out.println("Map contains " + lhMapNumbers.size() + " mappings"); //empty or clear LinkedHashMap lhMapNumbers.clear(); System.out.println("Map contains " + lhMapNumbers.size() + " mappings"); |
Output
|
1 2 |
Map contains 3 mappings Map contains 0 mappings |
How to check if the LinkedHashMap is empty using the isEmpty method?
The isEmpty method returns true if the map contains no key-value mappings. It returns false if there is at least one mapping in the map.
|
1 2 3 4 5 6 7 8 9 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); System.out.println("Is LinkedHashMap empty? " + lhMapNumbers.isEmpty()); lhMapNumbers.clear(); System.out.println("Is LinkedHashMap empty? " + lhMapNumbers.isEmpty()); |
Output
|
1 2 |
Is LinkedHashMap empty? false Is LinkedHashMap empty? true |
You can also use the size method to check if the LinkedHashMap is empty. However, using the isEmpty method makes the code cleaner and readable.
How to get all keys of the LinkedHashMap using the keySet method?
The keySet method returns a Set view containing all the keys of the LinkedHashMap object. The key set returned by this method is backed by the original LinkedHashMap object. Any changes you make to the key set will be reflected in the original LinkedHashMap object, and vice versa.
|
1 2 3 4 5 6 7 8 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); Set<String> setKeys = lhMapNumbers.keySet(); System.out.println("LinkedHashMap get all keys: " + setKeys); |
Output
|
1 |
LinkedHashMap get all keys: [1, 2, 3] |
How to get all values of the LinkedHashMap using the values method?
The values method of the LinkedHashMap class returns a Collection containing all the values contained in the map object.
|
1 2 3 4 5 6 7 8 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); Collection<String> cValues = lhMapNumbers.values(); System.out.println("LinkedHashMap get all values: " + cValues); |
Output
|
1 |
LinkedHashMap get all values: [One, Two, Three] |
Please note that the Collection returned by the values method is backed by the original map. Any changes made to the original LinkedHashMap object will reflect in the Collection. Similarly, any changes made to the Collection will reflect in the original map object.
How to get all entries or all mappings of LinkedHashMap using the entrySet method?
The entrySet method of the LinkedHashMap class returns the Set view of key-value mappings or entries contained in the map.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //get all mappings of the LinkedHashMap Set<Entry<String, String>> entrySet = lhMapNumbers.entrySet(); //iterate the entry set for(Entry<String, String> entry: entrySet){ System.out.println(entry.getKey() + "=>" + entry.getValue()); } |
Output
|
1 2 3 |
1=>One 2=>Two 3=>Three |
The Set returned by this method is backed by the original map object. So any changes you make to this set will reflect in the original map, and vice versa.
How to check if the LinkedHashMap contains a key using the containsKey method?
The containsKey method of the LinkedHashMap class is used to check if the LinkedHashMap contains the specified key. It returns true if the key is associated with any value. It returns false if the key is not mapped to any value in the map.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); /* * This will print true as the key 2 is mapped to Two */ System.out.println( lhMapNumbers.containsKey("2") ); /* * this will print false as the key 5 is * not associated with any values in the map */ System.out.println( lhMapNumbers.containsKey("5") ); |
Output
|
1 2 |
true false |
Note: If the LinkedHashHashMap key is an object of a custom class, the class must override the equals and hashCode methods for the containsKey method to work.
How to check if the LinkedHashMap contains a value using the containsValue method?
The containsValue method of the LinkedHashMap class returns true if the given value is associated with one or more keys.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); lhMapNumbers.put("4", "Two"); /* * This will print true as value Two is associated * with keys 2 and 4 */ System.out.println( lhMapNumbers.containsValue("Two") ); /* * this will print false as value Five is * not associated with any keys in the map */ System.out.println( lhMapNumbers.containsValue("Five") ); |
Output
|
1 2 |
true false |
Note: If the LinkedHashHashMap value is an object of a custom class, the class must override the equals and hashCode methods for the containsValue method to work.
How to replace a value for a key in LinkedHashMap using the replace method?
The replace method of the LinkedHashMap class replaces a value for the specified key, only if the key is mapped to some value. If the key is not mapped to any value, this method does not create a new mapping like the put method.
Additionally, this method returns previously associated value with the key if the key is found in the map and value is replaced. It returns null if the value is not replaced or the key was mapped to a null value.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); //this will replace value "Two" with "Five". Returns old value i.e. "Two" System.out.println( lhMapNumbers.replace("2", "Five") ); //this will return null as key "5" does not exist System.out.println( lhMapNumbers.replace("5", "NewFive")); System.out.println("Map contains: " + lhMapNumbers); |
Output
|
1 2 3 |
Two null Map contains: {1=One, 2=Five, 3=Three} |
You can also use an overloaded replace method which replaces the value for the specified key, only if the key is mapped to the specified value. If the key is not mapped to the specified value, the value is not replaced. This method returns true if the value replaced, false otherwise.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
LinkedHashMap<String, String> lhMapNumbers = new LinkedHashMap<String, String>(); lhMapNumbers.put("1", "One"); lhMapNumbers.put("2", "Two"); lhMapNumbers.put("3", "Three"); /* * this will replace "Two" with "Five" and prints true * as "2" is currently mapped to "Two" */ System.out.println( lhMapNumbers.replace("2", "Two", "Five") ); /* * this will not make any replacement as the key * "3" is not mapped to "Four" */ System.out.println( lhMapNumbers.replace("3", "Four", "NewFour") ); //this will have no effect as key "5" does not exist in the map System.out.println( lhMapNumbers.replace("5", "Five", "NewFive") ); System.out.println("Map contains: " + lhMapNumbers); |
Output
|
1 2 3 4 |
true false false Map contains: {1=One, 2=Five, 3=Three} |
How to iterate through LinkedHashMap object?
How to iterate through LinkedHashMap keys?
To iterate over all the keys of the LinkedHashMap object, use the keySet method as given below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
LinkedHashMap<Integer, String> lhMapNumbers = new LinkedHashMap<Integer, String>(); lhMapNumbers.put(1, "One"); lhMapNumbers.put(2, "Two"); lhMapNumbers.put(3, "Three"); /* * Get all keys of LinkedHashMap using the keySet method */ Set<Integer> setKeys = lhMapNumbers.keySet(); //iterate through keys of the LinkedHashMap System.out.println( "Iterate over all keys of LinkedHashMap" ); for(Integer key : setKeys) System.out.println(key); |
Output
|
1 2 3 4 |
Iterate over all keys of LinkedHashMap 1 2 3 |
How to iterate through LinkedHashMap values?
To iterate over all the values of the LinkedHashMap object, use the values method as given below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
LinkedHashMap<Integer, String> lhMapNumbers = new LinkedHashMap<Integer, String>(); lhMapNumbers.put(1, "One"); lhMapNumbers.put(2, "Two"); lhMapNumbers.put(3, "Three"); /* * Get all values of LinkedHashMap using the values method */ Collection<String> cValues = lhMapNumbers.values(); //iterate through values of the LinkedHashMap System.out.println( "Iterate over all values of LinkedHashMap" ); for(String strValue : cValues) System.out.println(strValue); |
Output
|
1 2 3 4 |
Iterate over all values of LinkedHashMap One Two Three |
How to iterate through all LinkedHashMap mappings or entries?
To iterate over all the key value mappings of the LinkedHashMap object, use the entrySet method as given below.
|
1 2 3 4 5 6 7 8 9 10 |
LinkedHashMap<Integer, String> lhMapNumbers = new LinkedHashMap<Integer, String>(); lhMapNumbers.put(1, "One"); lhMapNumbers.put(2, "Two"); lhMapNumbers.put(3, "Three"); //iterate through key value mappings of the LinkedHashMap System.out.println( "Iterate over all key value mappings of LinkedHashMap" ); for(Map.Entry<Integer,String> entry : lhMapNumbers.entrySet()){ System.out.println( entry.getKey() + " => " + entry.getValue()); } |
Output
|
1 2 3 4 |
Iterate over all key value mappings of LinkedHashMap 1 => One 2 => Two 3 => Three |
How to clone a LinkedHashMap object using the clone method?
The clone method of the LinkedHashMap class returns a shallow copy of this map object. Actual key and value objects are not copied, only their references are copied that is why it is called a shallow copy. Please refer to below given example to understand it in more detail.
|
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 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
class Car{ private String carBrand; private String carName; public Car(String carBrand, String carName){ this.carBrand = carBrand; this.carName = carName; } public String getCarBrand() { return carBrand; } public void setCarBrand(String carBrand) { this.carBrand = carBrand; } public String getCarName() { return carName; } public void setCarName(String carName) { this.carName = carName; } //to print the object public String toString(){ return "[" + getCarBrand() + ", " + getCarName() + "]"; } } public class Example { public static void main(String[] args) { LinkedHashMap<Integer, Car> lhMapSmallCars = new LinkedHashMap<Integer, Car>(); lhMapSmallCars.put(1, new Car("Suzuki", "Alto")); lhMapSmallCars.put(2, new Car("Hyundai", "Eon")); lhMapSmallCars.put(3, new Car("Hyundai", "WagonR")); lhMapSmallCars.put(4, new Car("Datsun", "Go")); /* * To clone a LinkedHashMap object, use the clone method. */ LinkedHashMap<Integer, Car> lhMapSmallCarsCloned = (LinkedHashMap<Integer, Car>)lhMapSmallCars.clone(); System.out.println("Original LinkedHashMap: " + lhMapSmallCars); System.out.println("Cloned LinkedHashMap: " + lhMapSmallCarsCloned); /* * Adding or removing mappings from either of the LinkedHashMap objects * does not affect the other */ //remove a mapping from the original map lhMapSmallCars.remove(2); //add a new mapping to the cloned map lhMapSmallCarsCloned.put(5, new Car("Hyundai", "Santro")); System.out.println("Original LinkedHashMap: " + lhMapSmallCars); System.out.println("Cloned LinkedHashMap: " + lhMapSmallCarsCloned); /* * However, modifying actual value object changes both the map * objects. Reason is, the clone method copies the references of the * objects, not the actual objects. So both the maps refer to the same objects. */ //change a value object from the original map Car car = lhMapSmallCars.get(1); car.setCarName("Celerio"); //the change will be visible in the both the map objects System.out.println("Original LinkedHashMap: " + lhMapSmallCars); System.out.println("Cloned LinkedHashMap: " + lhMapSmallCarsCloned); } } |
Output
|
1 2 3 4 5 6 |
Original LinkedHashMap: {1=[Suzuki, Alto], 2=[Hyundai, Eon], 3=[Hyundai, WagonR], 4=[Datsun, Go]} Cloned LinkedHashMap: {1=[Suzuki, Alto], 2=[Hyundai, Eon], 3=[Hyundai, WagonR], 4=[Datsun, Go]} Original LinkedHashMap: {1=[Suzuki, Alto], 3=[Hyundai, WagonR], 4=[Datsun, Go]} Cloned LinkedHashMap: {1=[Suzuki, Alto], 2=[Hyundai, Eon], 3=[Hyundai, WagonR], 4=[Datsun, Go], 5=[Hyundai, Santro]} Original LinkedHashMap: {1=[Suzuki, Celerio], 3=[Hyundai, WagonR], 4=[Datsun, Go]} Cloned LinkedHashMap: {1=[Suzuki, Celerio], 2=[Hyundai, Eon], 3=[Hyundai, WagonR], 4=[Datsun, Go], 5=[Hyundai, Santro]} |
The below given additional LinkedHashMap examples will help you understand the concepts in more detail.
LinkedHashMap Examples
- How to create LinkedHashMap in Java (LinkedHashMap constructors)
- How to print LinkedHashMap
- How to add mappings to LinkedHashMap in Java
- How to check LinkedHashMap size
- How to check if LinkedHashMap is empty
- How to clear or remove all mappings from LinkedHashMap
- How to convert LinkedHashMap to List in Java
- Sort LinkedHashMap by keys
- Sort LinkedHashMap by values
- Convert ArrayList to LinkedHashMap in Java
- Convert LinkedHashMap to two arrays
- How to iterate LinkedHashMap
- How to iterate LinkedHashMap in reverse order
- Java LinkedHashMap forEach example
- How to get all keys of LinkedHashMap in Java
- How to get all values of LinkedHashMap in Java
- How to get first or last entry from Java LinkedHashMap
- How to check if LinkedHashMap contains a key
- How to check if LinkedHashMap contains a value
- How to get LinkedHashMap value by index
- How to get LinkedHashMap key by index
- How to maintain insertion order of elements of HashMap using LinkedHashMap
References:
Java LinkedHashMap Javadoc
Please let me know if you liked the Java LinkedHashMap tutorial with examples in the comments section below.
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
