{"id":239,"date":"2016-04-28T19:16:00","date_gmt":"2016-04-28T19:16:00","guid":{"rendered":"http:\/\/www.java2blog.com\/?p=239"},"modified":"2021-01-10T16:41:14","modified_gmt":"2021-01-10T11:11:14","slug":"linkedhashmap-in-java-with-example","status":"publish","type":"post","link":"https:\/\/java2blog.com\/linkedhashmap-in-java-with-example\/","title":{"rendered":"LinkedHashMap in java"},"content":{"rendered":"<p>LinkedHashMap is a Hashtable and linked list-based implementation of Map interface, with predictable insertion order. It maintains <a href=\"https:\/\/java2blog.com\/doubly-linked-list-java\/\" rel=\"noopener noreferrer\" target=\"_blank\">double linked list<\/a> of all its entries, that&#8217;s how it differs from <a href=\"http:\/\/www.java2blog.com\/2014\/02\/how-hashmap-works-in-java.html\" target=\"_blank\" rel=\"noopener noreferrer\">HashMap<\/a>.<br \/>\n<div id=\"toc_container\" class=\"toc_light_blue no_bullets\"><p class=\"toc_title\">Table of Contents<\/p><ul class=\"toc_list\"><li><a href=\"#Java_LinkedHashMap\">Java LinkedHashMap<\/a><\/li><li><a href=\"#LinkedHashMap_Constructors\">LinkedHashMap Constructors<\/a><\/li><li><a href=\"#Add_key-value_pairs_to_LinkedHashMap\">Add key-value pairs to LinkedHashMap<\/a><\/li><li><a href=\"#Remove_entries_from_LinkedHashMap\">Remove entries from LinkedHashMap<\/a><\/li><li><a href=\"#Important_LinkedHashMap_methods\">Important LinkedHashMap methods<\/a><\/li><li><a href=\"#Get_entrySet_keySet_and_values_from_LinkedHashMap\">Get entrySet(), keySet() and values() from LinkedHashMap<\/a><ul><li><a href=\"#entrySet\">entrySet()<\/a><\/li><li><a href=\"#keySet\">keySet()<\/a><\/li><li><a href=\"#values\">values()<\/a><\/li><\/ul><\/li><li><a href=\"#Iterate_over_LinkedHashMap\">Iterate over LinkedHashMap<\/a><\/li><li><a href=\"#Access_order_LinkedHashMap\">Access order LinkedHashMap<\/a><\/li><li><a href=\"#Is_LinkedHashMap_thread-safe\">Is LinkedHashMap thread-safe?<\/a><\/li><li><a href=\"#Conclusion\">Conclusion<\/a><\/li><\/ul><\/div>\n\n<h2><span id=\"Java_LinkedHashMap\">Java LinkedHashMap<\/span><\/h2>\n<p>Some points about LinkedHashMap<\/p>\n<ol>\n<li>LinkedHashMap implements Map interface and extends <a href=\"https:\/\/java2blog.com\/hashmap-in-java-with-examples\/\" rel=\"noopener noreferrer\" target=\"_blank\">HashMap<\/a> class.<\/li>\n<li>LinkedHashMap maintains insertion order, so when you will be able to access elements in the order they were inserted like <a href=\"https:\/\/java2blog.com\/arraylist-in-java-with-example\/\" rel=\"noopener noreferrer\" target=\"_blank\">ArrayList<\/a>.<\/li>\n<li>LinkedHashMap maintains doubly Linked list to maintain insertion order.<\/li>\n<li>It is not synchronized and is not thread-safe.<\/li>\n<li>Duplicate keys are not allowed<\/li>\n<li>One <code>null<\/code> key and multiple <code>null<\/code> values are allowed<\/li>\n<\/ol>\n<p><img decoding=\"async\" loading=\"lazy\" src=\"https:\/\/java2blog.com\/wp-content\/uploads\/2016\/04\/LinkedHashMap.jpg\" alt=\"LinkedHashMap\" width=\"350\" height=\"500\" class=\"aligncenter size-full wp-image-9350\" \/><\/p>\n<blockquote><p><strong>Did you notice LinkedHashMap implements Map interface even if AbstractMap and <a href=\"https:\/\/java2blog.com\/hashmap-in-java-with-examples\/\" rel=\"noopener noreferrer\" target=\"_blank\">HashMap<\/a> already implements it?<\/strong><br \/>\nYes, Just to make things more obvious, LinkedHashMap implements Map <a href=\"https:\/\/java2blog.com\/interface-in-java-with-example\/\" target=\"_blank\" rel=\"noopener noreferrer\">interface<\/a> again and there is nothing wrong in implementing interface again. You don&#8217;t have to go through class Hierarchy to find it out that LinkedHashMap implements Map interface.<\/p><\/blockquote>\n<h2><span id=\"LinkedHashMap_Constructors\">LinkedHashMap Constructors<\/span><\/h2>\n<p>Java LinkedHashMap class has five <a href=\"https:\/\/java2blog.com\/constructor-java\/\" target=\"_blank\" rel=\"noopener noreferrer\">constructors<\/a><br \/>\n<code>public LinkedHashMap()<\/code>: This is the <a href=\"https:\/\/java2blog.com\/java-default-constructor\/\" target=\"_blank\" rel=\"noopener noreferrer\">default constructor<\/a> and used mostly. It creates an empty LinkedHashMap with default initial capacity of 16 and load factor 0.75.<br \/>\n<code>public LinkedHashMap(int initialCapacity)<\/code>: This constructor is used to specify the initial capacity of LinkedHashMap and default load factor 0.75.<br \/>\n<code>public LinkedHashMap(int initialCapacity,float loadFactor)<\/code>: This constructor is used to specify initial capacity of the LinkedHashMap and load factor. In most of the scenarios, you should avoid using this constructor unless you are sure about this as load factor 0.75 provides a good tradeoff between time and space.<br \/>\n<code>public LinkedHashMap(Map&lt;? extends K,? extends V&gt; m)<\/code>: This constructor is used when you want to create LinkedHashMap from some other Map such as <a href=\"https:\/\/java2blog.com\/treemap-in-java-with-examples\/\" target=\"_blank\" rel=\"noopener noreferrer\">TreeMap<\/a> or <a href=\"https:\/\/java2blog.com\/hashmap-in-java-with-examples\/\" target=\"_blank\" rel=\"noopener noreferrer\">HashMap<\/a>.<br \/>\n<code>public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)<\/code>: This constructor is used to specify initial capacity, load factor and access order of HashMap. If we pass access order as true, then it will list entries based on access order.<\/p>\n<h2><span id=\"Add_key-value_pairs_to_LinkedHashMap\">Add key-value pairs to LinkedHashMap<\/span><\/h2>\n<p>We can use <code>put()<\/code> method to add entries to <code>LinkedHashMap<\/code> similar to HashMap.<br \/>\n<strong>Example:<\/strong><\/p>\n<pre class=\"java\" name=\"code\">package org.arpit.java2blog;\nimport java.util.LinkedHashMap;\nimport java.util.Map;\n\npublic class LinkedHashMapEntriesMain {\n\n    public static void main(String[] args) {\n        Map&lt;Integer, String&gt; studentMap = new LinkedHashMap&lt;Integer, String&gt;();\n        \/\/ Putting key-values pairs in LinkedHashMap\n        studentMap.put(1, \"Arvind\");\n        studentMap.put(2, \"Andy\");\n        studentMap.put(3, \"Mohan\");\n        studentMap.put(4, \"Virat\");\n\n        System.out.println(studentMap);\n    }\n}\n<\/pre>\n<p>When you run above program, you will get below output<\/p>\n<div class=\"content-box-green\">{1=Arvind, 2=Andy, 3=Mohan, 4=Virat}<\/div>\n<p>As you can see, all the entries are printed in insertion order as expected.<br \/>\n<strong>What if you want to add entries only if it is not already present in LinkedHashMap?<\/strong><br \/>\nYou can use <code>putIfAbsent()<\/code> the method in this scenario.<\/p>\n<blockquote><p>\n<span style=\"font-size: 1.2em\">&#x1f4a1; <strong>Did you know?<\/strong><\/style>\n<p>After Java 7, you can use diamond operator(<code>&lt;&gt;<\/code>) to initialize Map.<br \/>\nYou can change<br \/>\n<code>Map&lt;Integer, String&gt; studentMap = new LinkedHashMap&lt;Integer, String&gt;();<\/code><br \/>\nto<br \/>\n<code>Map&lt;Integer, String&gt; studentMap = new LinkedHashMap&lt;&gt;();<\/code>\n<\/p><\/blockquote>\n<h2><span id=\"Remove_entries_from_LinkedHashMap\">Remove entries from LinkedHashMap<\/span><\/h2>\n<p>There are two ways to remove entries in LinkedHashMap.<\/p>\n<ol>\n<li><code>remove(Object key)<\/code>: It removes key from LinkedHashMap<\/li>\n<li><code>remove(Object key,Object value)<\/code>: It removes key if value is same as passed parameter value.<\/li>\n<\/ol>\n<pre class=\"java\" name=\"code\">package org.arpit.java2blog.HashMap;\n\npackage org.arpit.java2blog;\nimport java.util.LinkedHashMap;\nimport java.util.Map;\n\npublic class LinkedHashMapRemoveMain {\n\n    public static void main(String[] args) {\n        Map&lt;String, Integer&gt; travelFareMap = new LinkedHashMap&lt;String, Integer&gt;();\n        \/\/ Putting key-values pairs in LinkedHashMap\n\n        travelFareMap.put(\"Bus\", 120);\n        travelFareMap.put(\"Car\", 2200);\n        travelFareMap.put(\"Rail\", 680);\n        travelFareMap.put(\"Flight\", 4000);\n        System.out.println(travelFareMap);\n\n        \/\/ Remove car key\n        Integer fareCar = travelFareMap.remove(\"Car\");\n        System.out.println(\"===============================\");\n        System.out.println(\"Vehicle Car with fare \"+fareCar+\" removed from HashMap\");\n        System.out.println(travelFareMap);\n        System.out.println(\"================================\");\n\n        \/\/ Remove Rail if fate is 800\n        boolean isCarRemoved = travelFareMap.remove(\"Rail\",800);\n        \/\/ Rail key won't be removed as associated value is 680\n        System.out.println(\"Did car removed from LinkedHashMap: \"+isCarRemoved);\n        System.out.println(travelFareMap);\n        System.out.println(\"===============================\");\n\n        \/\/ Remove Flight if fare is 4000\n        boolean isFlightRemoved = travelFareMap.remove(\"Flight\",4000);\n        \/\/ flight key will be removed as associated value is 4000\n        System.out.println(\"Did Flight removed from LinkedHashMap: \"+isFlightRemoved);\n        System.out.println(travelFareMap);\n        System.out.println(\"===============================\");\n\n    }\n}\n<\/pre>\n<p><strong>Output:<\/strong><\/p>\n<div class=\"content-box-purple\">{Bus=120, Car=2200, Rail=680, Flight=4000}<br \/>\n===============================<br \/>\nVehicle Car with fare 2200 removed from HashMap<br \/>\n{Bus=120, Rail=680, Flight=4000}<br \/>\n================================<br \/>\nDid car removed from LinkedHashMap: false<br \/>\n{Bus=120, Rail=680, Flight=4000}<br \/>\n===============================<br \/>\nDid Flight removed from LinkedHashMap: true<br \/>\n{Bus=120, Rail=680}<br \/>\n===============================\n<\/div>\n<h2><span id=\"Important_LinkedHashMap_methods\">Important LinkedHashMap methods<\/span><\/h2>\n<p><code>get()<\/code>: Retrieve value from the LinkedHashMap<br \/>\n<code>put()<\/code>: Put value into the LinkedHashMap<br \/>\n<code>isEmpty<\/code>: Check if LinkedHashMap is empty.<br \/>\n<code>containsKey()<\/code>: Check if key present is LinkedHashMap<br \/>\n<code>containsValue()<\/code>: Check if value exists in LinkedHashMap<br \/>\n<code>size()<\/code>: Check size of the LinkedHashMap<br \/>\n<code>clear()<\/code>: To remove all elements from LinkedHashMap<br \/>\n<code>clone()<\/code>: It creates shallow copy of LinkedHashMap.<\/p>\n<p>Here is an example to cover these methods.<\/p>\n<pre class=\"java\" name=\"code\">package org.arpit.java2blog;\n\nimport java.util.LinkedHashMap;\nimport java.util.Map;\n\npublic class LinkedHashMapMethodsMain {\n\n    public static void main(String[] args) {\n        Map&lt;String, String&gt; profDeptmap = new LinkedHashMap&lt;&gt;();\n\n        \/\/check if map is empty\n        boolean empty = profDeptmap.isEmpty();\n        System.out.println(\"is profDeptmap empty: \"+empty);\n\n        \/\/ Putting key-values pairs in HashMap\n        profDeptmap.put(\"Arvind\",\"Chemistry\");\n        profDeptmap.put(\"Venkat\", \"Physics\");\n        profDeptmap.put(\"Mary\", \"History\");\n        profDeptmap.put(\"David\",\"Maths\");\n\n      System.out.println(profDeptmap);\n        \/\/check size of map\n        System.out.println(\"size of profDeptmap: \"+profDeptmap.size());\n\n        \/\/ get value from LinkedHashMap\n        System.out.println(\"Venkat's department: \"+profDeptmap.get(\"Venkat\"));\n        \/\/ Hamlet department will be null as we don't have key as \"Hamlet\"\n        System.out.println(\"Hamlet's department: \"+profDeptmap.get(\"Hamlet\"));\n\n        if(profDeptmap.containsKey(\"David\"))\n        {\n            System.out.println(\"profDeptmap has David as key\");\n        }\n\n        if(profDeptmap.containsValue(\"History\"))\n        {\n            System.out.println(\"profDeptmap has History as value\");\n        }\n\n        \/\/ Removing all entries from Map\n        profDeptmap.clear();\n        System.out.println(profDeptmap);\n    }\n}\n<\/pre>\n<p><strong>Output:<\/strong><\/p>\n<div class=\"content-box-red\">is profDeptmap empty: true<br \/>\n{Arvind=Chemistry, Venkat=Physics, Mary=History, David=Maths}<br \/>\nsize of profDeptmap: 4<br \/>\nVenkat&#8217;s department: Physics<br \/>\nHamlet&#8217;s department: null<br \/>\nprofDeptmap has David as key<br \/>\nprofDeptmap has History as value<br \/>\n{}\n<\/div>\n<h2><span id=\"Get_entrySet_keySet_and_values_from_LinkedHashMap\">Get entrySet(), keySet() and values() from LinkedHashMap<\/span><\/h2>\n<h3><span id=\"entrySet\">entrySet()<\/span><\/h3>\n<p><code>entrySet()<\/code>: As HashMap stores key value pair in form of <code>Entry<\/code>, we can retrieve entrySet() by calling <code>map.entrySet()<\/code><\/p>\n<h3><span id=\"keySet\">keySet()<\/span><\/h3>\n<p><code>keySet()<\/code>: Provides a set of keys.<\/p>\n<h3><span id=\"values\">values()<\/span><\/h3>\n<p><code>values()<\/code>: Provides a collection of values.<\/p>\n<p>Here is the example for the same.<\/p>\n<pre class=\"java\" name=\"code\">package org.arpit.java2blog;\n\nimport java.util.Collection;\nimport java.util.LinkedHashMap;\nimport java.util.Map;\nimport java.util.Map.Entry;\nimport java.util.Set;\n\npublic class LinkedHashMapMain {\n\n    public static void main(String[] args) {\n        Map&lt;Integer, String&gt; studentIDNameMap = new LinkedHashMap&lt;&gt;();\n\n        \/\/ Putting key-values pairs in LinkedHashMap\n        studentIDNameMap.put(1001,\"Andrew\");\n        studentIDNameMap.put(1002, \"Martin\");\n        studentIDNameMap.put(1003, \"Sameer\");\n        studentIDNameMap.put(1004,\"Venkat\");\n\n        \/\/ get entrySet\n        Set&lt;Entry&lt;Integer, String&gt;&gt; entrySet = studentIDNameMap.entrySet();\n        System.out.println(\"EntrySet: \"+entrySet);\n\n        \/\/ get keySet\n        Set&lt;Integer&gt; keySet = studentIDNameMap.keySet();\n        System.out.println(\"keySet: \"+keySet);\n\n        \/\/ get values\n        Collection&lt;String&gt; values = studentIDNameMap.values();\n        System.out.println(\"values: \"+values);\n    }\n}\n<\/pre>\n<p><strong>Output:<\/strong><\/p>\n<div class=\"content-box-blue\">\nEntrySet: [1001=Andrew, 1002=Martin, 1003=Sameer, 1004=Venkat]\nkeySet: [1001, 1002, 1003, 1004]\nvalues: [Andrew, Martin, Sameer, Venkat]\n<\/div>\n<p>As you can see, all the pairs or values are in insertion order.<\/p>\n<h2><span id=\"Iterate_over_LinkedHashMap\">Iterate over LinkedHashMap<\/span><\/h2>\n<p>There are many ways to <a href=\"https:\/\/java2blog.com\/how-to-iterate-over-map-or-hashmap-in\/\" target=\"_blank\" rel=\"noopener noreferrer\">iterate over LinkedHashMap<\/a><\/p>\n<ol>\n<li>Iterating over LinkedHashMap using <code>keyset()<\/code><\/li>\n<li>Iterating over LinkedHashMap using <code>keyset()<\/code> with <a href=\"https:\/\/java2blog.com\/java-8-foreach-examples\/\" target=\"_blank\" rel=\"noopener noreferrer\">foreach<\/a>() and <a href=\"https:\/\/java2blog.com\/lambda-expressions-in-java-8\/\" target=\"_blank\" rel=\"noopener noreferrer\">lambda expression<\/a>( <a href=\"https:\/\/java2blog.com\/java-8-tutorial\/\" target=\"_blank\" rel=\"noopener noreferrer\">java 8<\/a>)<\/li>\n<li>Iterating over LinkedHashMap using\n<pre class=\"lang:default decode:1 inline:1 \" >foreach() <\/pre>\n<p>and lambda expression (java 8)<\/li>\n<li>Iterating over LinkedHashMap&#8217;s <code>entrySet()<\/code> using <code>iterator<\/code><\/li>\n<li>Iterating over LinkedHashMap&#8217;s <code>entrySet()<\/code> using foreach() and lambda expression [<a href=\"https:\/\/java2blog.com\/java-8-tutorial\/\" target=\"_blank\" rel=\"noopener noreferrer\">java 8<\/a>]<\/li>\n<li>Iterating over LinkedHashMap&#8217;s <code>entrySet()<\/code> using foreach loop<\/li>\n<\/ol>\n<pre class=\"java\" name=\"code\">package org.arpit.java2blog;\n\nimport java.util.Iterator;\nimport java.util.LinkedHashMap;\nimport java.util.Map;\nimport java.util.Map.Entry;\n\npublic class LinkedHashMapIterationMain {\n\n    public static void main(String[] args) {\n\n        Map&lt;String, Long&gt; countryPopulationMap = new LinkedHashMap&lt;&gt;();\n\n        \/\/ Putting key-values pairs in LinkedHashMap\n        countryPopulationMap.put(\"India\",13000L);\n        countryPopulationMap.put(\"China\", 15000L);\n        countryPopulationMap.put(\"Germany\", 9000L);\n        countryPopulationMap.put(\"France\",7000L);\n\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap with foreach and lambda:\");\n        countryPopulationMap.forEach((country,population) -&gt; { \n            System.out.println(country+\" --&gt; \"+population);\n            } \n        );\n\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap using keyset() with foreach loop:\");\n        for(String user:countryPopulationMap.keySet())\n        {\n            System.out.println(user+\" --&gt; \"+countryPopulationMap.get(user));\n        }\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap keyset() with foreach and lambda:\");\n        countryPopulationMap.keySet().forEach((user) -&gt; { \n            System.out.println(user+\" --&gt; \"+countryPopulationMap.get(user));\n            } \n        );\n\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap entrySet with iterator\");\n        Iterator&lt;Entry&lt;String, Long&gt;&gt; iterator = countryPopulationMap.entrySet().iterator();\n        while(iterator.hasNext())\n        {\n            Entry&lt;String, Long&gt; next = iterator.next();\n            System.out.println(next.getKey()+\" --&gt; \"+next.getValue());\n        }\n\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap's entrySet with foreach and lambda\");\n        countryPopulationMap.entrySet().forEach((entry) -&gt; { \n            System.out.println(entry.getKey()+\" --&gt; \"+entry.getValue());\n            } \n        );\n\n        System.out.println(\"=========================================================\");\n        System.out.println(\"Iterating over LinkedHashMap's entrySet with foreach loop\");\n        for(Map.Entry&lt;String, Long&gt; entry:countryPopulationMap.entrySet())\n        {\n            System.out.println(entry.getKey()+\" --&gt; \"+entry.getValue());\n        }\n\n    }\n}\n<\/pre>\n<p><strong>Output:<\/strong><\/p>\n<div class=\"content-box-grey\">\n=========================================================<br \/>\nIterating over LinkedHashMap with foreach and lambda:<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000<br \/>\n=========================================================<br \/>\nIterating over LinkedHashMap using keyset() with foreach loop:<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000<br \/>\n=========================================================<br \/>\nIterating over LinkedHashMap keyset() with foreach and lambda:<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000<br \/>\n=========================================================<br \/>\nIterating over LinkedHashMap entrySet with iterator<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000<br \/>\n=========================================================<br \/>\nIterating over LinkedHashMap&#8217;s entrySet with foreach and lambda<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000<br \/>\n=========================================================<br \/>\nIterating over LinkedHashMap&#8217;s entrySet with foreach loop<br \/>\nIndia &#8211;> 13000<br \/>\nChina &#8211;> 15000<br \/>\nGermany &#8211;> 9000<br \/>\nFrance &#8211;> 7000\n<\/div>\n<h2><span id=\"Access_order_LinkedHashMap\">Access order LinkedHashMap<\/span><\/h2>\n<p>In case, if you want to retrieve entries from LinkedHashMap in access order, you can use <code>LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)<\/code> <a href=\"https:\/\/java2blog.com\/constructor-java\/\" rel=\"noopener noreferrer\" target=\"_blank\">constructor<\/a>.<br \/>\nLet me provide you realtime usecase of LinkedHashMap with access order.<\/p>\n<p>You can use LinkedHashMap with access order to implement <a href=\"https:\/\/java2blog.com\/lru-cache-implementation-java\/\" rel=\"noopener noreferrer\" target=\"_blank\">LRU cache<\/a>.<br \/>\nCreate a class named <code>LRULHCache<\/code><\/p>\n<pre class=\"lang:java mark:10 decode:1 \" >\npackage org.arpit.java2blog;\nimport java.util.LinkedHashMap; \nimport java.util.Map; \n\nclass LRULHCache&lt;K,V&gt; { \n    private LinkedHashMap&lt;K, V&gt; map; \n    public LRULHCache(int capacity) \n    { \n        map = new LinkedHashMap&lt;K, V&gt;(capacity, 0.75f, true) { \n            protected boolean removeEldestEntry(Map.Entry eldest) \n            { \n                return size() &gt; capacity; \n            } \n        }; \n    } \n\n    \/\/ This method works in O(1) \n    public V get(K key) \n    { \n        return map.get(key); \n    } \n\n    \/\/ This method works in O(1) \n    public void set(K key, V value) \n    { \n        map.put(key, value); \n    } \n\n    @Override\n    public String toString() {\n        return \"LinkedHashMap: \"+map.toString();\n    }\n} \n\npublic class LinkedHashMapAccessOrderMain { \n\n    public static void main(String[] args) \n    { \n        LRULHCache&lt;Integer,Integer&gt; lruLHCache = new LRULHCache&lt;&gt;(2);\n        lruLHCache.set(2, 12000);\n        lruLHCache.set(40, 70000);\n\n        System.out.println(lruLHCache);\n\n        \/\/ renews the entry\n        System.out.println(lruLHCache.get(2));\n\n        System.out.println(lruLHCache);\n\n        lruLHCache.set(20, 70000);\n\n        System.out.println(lruLHCache);\n\n        System.out.println(lruLHCache.get(2));\n\n        System.out.println(lruLHCache);\n\n        System.out.println(lruLHCache.get(40));\n\n    } \n} \n<\/pre>\n<p><strong>Output<\/strong><\/p>\n<div class=\"content-box-green\">LinkedHashMap: {2=12000, 40=70000}<br \/>\n12000<br \/>\nLinkedHashMap: {40=70000, 2=12000}<br \/>\nLinkedHashMap: {2=12000, 20=70000}<br \/>\n12000<br \/>\nLinkedHashMap: {20=70000, 2=12000}<br \/>\nnull\n<\/div>\n<p>As you can see we have created LRULHCache with capacity 2 and once we call <code>get()<\/code>, LinkedHashMap is renewed with that key.<\/p>\n<h2><span id=\"Is_LinkedHashMap_thread-safe\"> Is LinkedHashMap thread-safe?<\/span><\/h2>\n<p>LinkedHashMap is not thread-safe by default and it can give non-deterministic results in case of a multithreaded environment.<\/p>\n<p>If multiple threads try to access LinkedHashMap and one of them does the structural modification, then it should be externally synchronized.<\/p>\n<p>Best way to do this at LinkedHashMap creation time.<\/p>\n<pre class=\"lang:java decode:1 \" >\nMap m=Collections.synchronizedMap(new LinkedHashMap());\n<\/pre>\n<p>I have already provided an example for <a href=\"https:\/\/java2blog.com\/hashmap-in-java-with-examples\/#is_HashMap_thread-safe\" rel=\"noopener noreferrer\" target=\"_blank\">HashMap thread safety<\/a>, since same example is applicable for LinkedHashMap, you can go through <a href=\"https:\/\/java2blog.com\/hashmap-in-java-with-examples\/#is_HashMap_thread-safe\" rel=\"noopener noreferrer\" target=\"_blank\">this<\/a>.<\/p>\n<h2><span id=\"Conclusion\">Conclusion<\/span><\/h2>\n<p>You have learned about basics of LinkedHashMap, how to create a LinkedHashMap and add key-value pairs to it, important LinkedHashMap methods, how to iterate over LinkedHashMap and thread safety issues with LinkedHashMap and how to synchronized a LinkedHashMap.<br \/>\nThat&#8217;s all about HashMap in java.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Table of ContentsJava LinkedHashMapLinkedHashMap ConstructorsAdd key-value pairs to LinkedHashMapRemove entries from LinkedHashMapImportant LinkedHashMap methodsGet entrySet(), keySet() and values() from LinkedHashMapentrySet()keySet()values()Iterate over LinkedHashMapAccess order LinkedHashMapIs LinkedHashMap thread-safe?Conclusion LinkedHashMap is a Hashtable and linked list-based implementation of Map interface, with predictable insertion order. It maintains double linked list of all its entries, that&#8217;s how it differs from [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"_mi_skip_tracking":false},"categories":[44],"tags":[],"_links":{"self":[{"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/posts\/239"}],"collection":[{"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/comments?post=239"}],"version-history":[{"count":0,"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/posts\/239\/revisions"}],"wp:attachment":[{"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/media?parent=239"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/categories?post=239"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/java2blog.com\/wp-json\/wp\/v2\/tags?post=239"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}