LinkedHashMap源碼分析

1. LinkedHashMap 與 HashMap 的關系 2. LinkedHashMap 雙向鏈表的構建過程 3. LinkedHashMap 刪除節點的過程 4. LinkedHashMap 如何維持訪問順序 5. LinkedHashMap - LRU (Least Recently Used) 最簡單的構建方式

LinkedHashMap 與 HashMap 的關系

Java部分容器體系圖：

• LinkedHashMap 直接繼承自HashMap

  1. hash算法定位， 2. 哈希表由數組和單鏈表構成 3. 單鏈表長度超過8的時候轉化為紅黑樹 4. 擴容體系(負載因子.)

• 優點

  1. 內部維護了一個雙向鏈表，解決 HashMap不能隨保持遍歷順序和插入順序一致的問題 2. 元素的訪問順序也提供了相關支持，也就是我們常說的 LRU（最近最少使用）原則 （最簡單的LRU實現方式.）

LinkedHashMap 雙向鏈表的構建過程

• 假設圖片中紅黃箭頭代表元素添加順序，藍箭頭代表單鏈表各個元素的存儲順序。head 表示雙向鏈表頭部，tail 代表雙向鏈表尾部
• LinkedHashMap 數據結構和Hashmap 同樣為： 數組 + 單鏈表 + 紅黑樹，從上邊的圖片我們也可以看出 底層的存儲結構并沒有發生變化
• 唯一變化的是使用雙向鏈表（圖中紅黃箭頭部分）記錄了元素的添加順序，我們知道 HashMap 中的 Node 節點只有 next 指針，對于雙向鏈表而言只有 next 指針是不夠的，所以 LinkedHashMap 對于 Node 節點進行了拓展：

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);} }

• LinkedHashMap 基本存儲單元 Entry<K,V> 繼承自 HashMap.Node<K,V>,并在此基礎上添加了 before 和 after 這兩個指針變量。
• 這 before 變量在每次添加元素的時候將會鏈接上一次添加的元素，而上一次添加的元素的 after 變量將指向該次添加的元素，來形成雙向鏈接。
• 值得注意的是 LinkedHashMap 并沒有覆寫任何關于 HashMap put 方法。所以調用 LinkedHashMap 的 put 方法實際上調用了父類 HashMap 的方法。為了方便理解我們這里放一下 HashMap 的 putVal 方法。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; Node<K,V> p; int n, i;if ((tab = table) == null || (n = tab.length) == 0)n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);else {// 發生 hash 碰撞了Node<K,V> e; K k;if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;else if (p instanceof TreeNode){....}else {//hash 值計算出的數組索引相同，但 key 并不同的時候 循環整個單鏈表for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {//遍歷到尾部// 創建新的節點，拼接到鏈表尾部p.next = newNode(hash, key, value, null);....break;}//如果遍歷過程中找到鏈表中有個節點的 key 與 當前要插入元素的 key 相同，//此時 e 所指的節點為需要替換 Value 的節點，并結束循環if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;//移動指針 p = e;}}//如果循環完后 e!=null 代表需要替換e所指節點 Valueif (e != null) {V oldValue = e.value//保存原來的 Value 作為返回值// onlyIfAbsent 一般為 false 所以替換原來的 Valueif (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);//該方法在 LinkedHashMap 中的實現稍后說明return oldValue;}}//操作數增加++modCount;//如果 size 大于擴容閾值則表示需要擴容if (++size > threshold)resize();afterNodeInsertion(evict);return null; }

可以看出每次添加新節點的時候實際上是調用 newNode 方法生成了一個新的節點，放到指定 hash 桶中,但是很明顯，HashMap 中 newNode 方法無法完成上述所講的雙向鏈表節點的間的關系，所以 LinkedHashMap 復寫了該方法：

// HashMap newNode 中實現 Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {return new Node<>(hash, key, value, next); }// LinkedHashMap newNode 的實現 Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {LinkedHashMap.Entry<K,V> p =new LinkedHashMap.Entry<K,V>(hash, key, value, e);// 將 Entry 接在雙向鏈表的尾部linkNodeLast(p);return p; }

可以看出雙向鏈表的操作一定在 linkNodeLast方法中實現：

/** * 該引用始終指向雙向鏈表的頭部 */ transient LinkedHashMap.Entry<K,V> head;/** * 該引用始終指向雙向鏈表的尾部 */ transient LinkedHashMap.Entry<K,V> tail; // newNode 中新節點，放到雙向鏈表的尾部 private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {// 添加元素之前雙向鏈表尾部節點LinkedHashMap.Entry<K,V> last = tail;// tail 指向新添加的節點tail = p;//如果之前 tail 指向 null 那么集合為空新添加的節點 head = tail = pif (last == null)head = p;else {// 否則將新節點的 before 引用指向之前當前鏈表尾部p.before = last;// 當前鏈表尾部節點的 after 指向新節點last.after = p;} }

LinkedHashMap 鏈表創建步驟，可用上圖幾個步驟來描述，藍色部分是 HashMap 的方法，而橙色部分為 LinkedHashMap 獨有的方法。

• 當我們創建一個新節點之后，通過linkNodeLast方法，將新的節點與之前雙向鏈表的最后一個節點（tail）建立關系，在這部操作中我們仍不知道這個節點究竟儲存在哈希表表的何處，但是無論他被放到什么地方，節點之間的關系都會加入雙向鏈表。如上述圖中節點 3 和節點 4 那樣彼此擁有指向對方的引用，這么做就能確保了雙向鏈表的元素之間的關系即為添加元素的順序。

LinkedHashMap 刪除節點的操作

如插入操作一樣，LinkedHashMap 沒有重寫的 remove 方法，使用的仍然是 HashMap 中的代碼，我們先來回憶一下 HashMap 中的 remove 方法：

public V remove(Object key) {Node<K,V> e;return (e = removeNode(hash(key), key, null, false, true)) == null ?null : e.value; }// HashMap 中實現final Node<K,V> removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {Node<K,V>[] tab; Node<K,V> p; int n, index;//判斷哈希表是否為空，長度是否大于0 對應的位置上是否有元素if ((tab = table) != null && (n = tab.length) > 0 &&(p = tab[index = (n - 1) & hash]) != null) {// node 用來存放要移除的節點， e 表示下個節點 k ，v 每個節點的鍵值Node<K,V> node = null, e; K k; V v;//如果第一個節點就是我們要找的直接賦值給 nodeif (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))node = p;else if ((e = p.next) != null) {// 遍歷紅黑樹找到對應的節點if (p instanceof TreeNode)node = ((TreeNode<K,V>)p).getTreeNode(hash, key);else {//遍歷對應的鏈表找到對應的節點do {if (e.hash == hash &&((k = e.key) == key ||(key != null && key.equals(k)))) {node = e;break;}p = e;} while ((e = e.next) != null);}}// 如果找到了節點// !matchValue 是否不刪除節點// (v = node.value) == value ||(value != null && value.equals(v))) 節點值是否相同，if (node != null && (!matchValue || (v = node.value) == value ||(value != null && value.equals(v)))) {//刪除節點 if (node instanceof TreeNode)((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);else if (node == p)tab[index] = node.next;elsep.next = node.next;++modCount;--size;afterNodeRemoval(node);// 注意這個方法 在 Hash表的刪除操作完成調用該方法return node;}}return null; }

LinkedHashMap 通過調用父類的 HashMap 的 remove 方法將 Hash 表的中節點的刪除操作完成即：

獲取對應 key 的哈希值 hash(key)，定位對應的哈希桶的位置

遍歷對應的哈希桶中的單鏈表或者紅黑樹找到對應 key 相同的節點，在最后刪除，并返回原來的節點。

對于 afterNodeRemoval（node） HashMap 中是空實現，而該方法，正是 LinkedHashMap 刪除對應節點在雙向鏈表中的關系的操作：

// 從雙向鏈表中刪除對應的節點 e 為已經刪除的節點 void afterNodeRemoval(Node<K,V> e) { LinkedHashMap.Entry<K,V> p =(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;// 將 p 節點的前后指針引用置為 null 便于內存釋放p.before = p.after = null;// p.before 為 null，表明 p 是頭節點 if (b == null)head = a;else//否則將 p 的前驅節點連接到 p 的后驅節點b.after = a;// a 為 null，表明 p 是尾節點if (a == null)tail = b;else //否則將 a 的前驅節點連接到 b a.before = b; }

因此 LinkedHashMap 節點刪除方式如下圖步驟一樣：

LinkedHashMap 維護節點訪問順序

LinkedHashMap 與 HashMap 添加和刪除元素的不同，可以看出除了維護 Hash表中元素的關系以外，LinkedHashMap 還在添加和刪除元素的時候維護著一個雙向鏈表。那么這個雙向鏈表究竟有何用呢？我們來看下邊這個例子，我們對比一下在相同元素添加順序的時候，遍歷 Map 得到的結果：

//Map<String, Integer> map = new HashMap<>();Map<String, Integer> map = new LinkedHashMap<>();// 使用三個參數的構造法方法來指定 accessOrder 參數的值//Map<String, Integer> map = new LinkedHashMap<>(10,0.75f,true);map.put("老大", 1);map.put("老二", 2);map.put("老三", 3);map.put("老四", 4);Set<Map.Entry<String, Integer>> entrySet = map.entrySet();Iterator iter1 = entrySet.iterator();while (iter1.hasNext()) {Map.Entry entry = (Map.Entry) iter1.next();System.out.print("key: " + entry.getKey() + " ");System.out.println("value: " + entry.getValue());}System.out.println("老三的值為：" + map.get("老三"));System.out.println("老大的值為：" + map.put("老大",1000));Iterator iter2 = entrySet.iterator();while (iter2.hasNext()) {// 遍歷時，需先獲取entry，再分別獲取key、valueMap.Entry entry = (Map.Entry) iter2.next();System.out.print("key: " + entry.getKey() + " ");System.out.println("value: " + entry.getValue());} /*** HashMap 遍歷結果*/ key: 老二 value: 2 key: 老四 value: 4 key: 老三 value: 3 key: 老大 value: 1 老三的值為：3 老大的值為：1 key: 老二 value: 2 key: 老四 value: 4 key: 老三 value: 3 key: 老大 value: 1000/*** LinkedHashMap 遍歷結果*/ key: 老大 value: 1 key: 老二 value: 2 key: 老三 value: 3 key: 老四 value: 4 老三的值為：3 老大的值為：1 key: 老大 value: 1000 key: 老二 value: 2 key: 老三 value: 3 key: 老四 value: 4

由上述方法結果可以看出：

HashMap 的遍歷結果是跟添加順序并無關系

LinkedHashMap 的遍歷結果就是添加順序

這就是雙向鏈表的作用。雙向鏈表能做的不僅僅是這些，在介紹雙向鏈表維護訪問順序前我們看來看一個重要的參數:

final boolean accessOrder;// 是否維護雙向鏈表中的元素訪問順序

該方法隨 LinkedHashMap 構造參數初始化，accessOrder 默認值為 false，我們可以通過三個參數構造方法指定該參數的值，參數定義為 final 說明外部不能改變。

public LinkedHashMap(int initialCapacity, float loadFactor) {super(initialCapacity, loadFactor);accessOrder = false; }public LinkedHashMap(int initialCapacity) {super(initialCapacity);accessOrder = false; }public LinkedHashMap() {super();accessOrder = false; }public LinkedHashMap(Map<? extends K, ? extends V> m) {super();accessOrder = false;putMapEntries(m, false); }//可以指定 LinkedHashMap 雙向鏈表維護節點訪問順序的構造參數 public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {super(initialCapacity, loadFactor);this.accessOrder = accessOrder; }//第一次遍歷 key: 老大 value: 1 key: 老二 value: 2 key: 老三 value: 3 key: 老四 value: 4老三的值為：3 老大的值為：1//第二次遍歷 key: 老二 value: 2 key: 老四 value: 4 key: 老三 value: 3 key: 老大 value: 1000

• 可以看出當我們使用 access 為 true 后，我們訪問元素的順序將會在下次遍歷的時候體現，最后訪問的元素將最后獲得。
• 其實這一切在 HashMap 源碼中也早有伏筆, 還記得我們在每次 putVal/get/repalce 最后都有一個 void afterNodeAccess(Node<K,V> e) 方法，該方法在 HashMap 中是空實現，但是在 LinkedHasMap 中該后置方法，將作為維護節點訪問順序的重要方法

//將被訪問節點移動到鏈表最后 void afterNodeAccess(Node<K,V> e) { // move node to lastLinkedHashMap.Entry<K,V> last;if (accessOrder && (last = tail) != e) {LinkedHashMap.Entry<K,V> p =(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;//訪問節點的后驅置為 null p.after = null;//如訪問節點的前驅為 null 則說明 p = headif (b == null)head = a;elseb.after = a;//如果 p 不為尾節點 那么將 a 的前驅設置為 b if (a != null)a.before = b;elselast = b;if (last == null)head = p;else {p.before = last;last.after = p;}tail = p;// 將 p 接在雙向鏈表的最后++modCount;} }

我們以下圖舉例看下整個 afterNodeAccess 過程是是怎么樣的，比如我們該次操作訪問的是 13 這個節點，而 14 是其后驅，11 是其前驅，且 tail = 14 。在通過 get 訪問 13 節點后， 13變成了 tail 節點，而14變成了其前驅節點，相應的 14的前驅變成 11 ，11的后驅變成了14， 14的后驅變成了13.

• 由此我們得知，LinkedHashMap 通過afterNodeAccess 這個后置操作，可以在 accessOrde = true 的時候，使雙向鏈表維護哈希表中元素的訪問順序。

// HashIterator nextNode 方法final Node<K,V> nextNode() {Node<K,V>[] t;Node<K,V> e = next;if (modCount != expectedModCount)throw new ConcurrentModificationException();if (e == null)throw new NoSuchElementException();//遍歷 table 尋找下個存有元素的 hash桶 if ((next = (current = e).next) == null && (t = table) != null) {do {} while (index < t.length && (next = t[index++]) == null);}return e;}// LinkedHashIterator nextNode 方法 final LinkedHashMap.Entry<K,V> nextNode() {LinkedHashMap.Entry<K,V> e = next;if (modCount != expectedModCount)throw new ConcurrentModificationException();if (e == null)throw new NoSuchElementException();current = e;//直接指向了當前節點的 after 后驅節點next = e.after;return e;}

更為明顯的我們可以查看兩者的 containsValue 方法：

//LinkedHashMap 中 containsValue 的實現 public boolean containsValue(Object value) {// 直接遍歷雙向鏈表去尋找對應的節點for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {V v = e.value;if (v == value || (value != null && value.equals(v)))return true;}return false; } //HashMap 中 containsValue 的實現 public boolean containsValue(Object value) {Node<K,V>[] tab; V v;if ((tab = table) != null && size > 0) {//遍歷 哈希桶索引for (int i = 0; i < tab.length; ++i) //遍歷哈希桶中鏈表或者紅黑樹for (Node<K,V> e = tab[i]; e != null; e = e.next) {if ((v = e.value) == value ||(value != null && value.equals(v)))return true;}}}return false; }

Java 中最簡單的 LRU 構建方式

• LRU 是 Least Recently Used 的簡稱，即近期最少使用
• 相信做 Android 的同學一定知道 LruCache 這個東西, Glide 的三級緩存中內存緩存中也使用了這個 LruCache 類。

LRU 算法實現的關鍵就像它名字一樣，當達到預定閾值的時候，這個閾值可能是內存不足，或者容量達到最大，找到最近最少使用的存儲元素進行移除，保證新添加的元素能夠保存到集合中。

• 下面我們來講解下，Java 中 LRU 算法的最簡單的實現。
• 我們還記得在每次調用 HashMap 的 putVal 方法添加完元素后還有個后置操作，void afterNodeInsertion(boolean evict) { } 就是這個方法。

LinkedHashMap 重寫了此方法：

// HashMap 中 putVal 方法實現 evict 傳遞的 true，表示表處于創建模式。 public V put(K key, V value) {return putVal(hash(key), key, value, false, true); }final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) { .... }//evict 由上述說明大部分情況下都傳 true 表示表處于創建模式 void afterNodeInsertion(boolean evict) { // possibly remove eldestLinkedHashMap.Entry<K,V> first;//由于 evict = true 那么當鏈表不為空的時候 且 removeEldestEntry(first) 返回 true 的時候進入if 內部if (evict && (first = head) != null && removeEldestEntry(first)) {K key = first.key;removeNode(hash(key), key, null, false, true);//移除雙向鏈表中處于 head 的節點} }//LinkedHashMap 默認返回 false 則不刪除節點。 返回 true 雙向鏈表中處于 head 的節點 protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {return false; }

• 由上述源碼可以看出，如果如果 removeEldestEntry(Map.Entry<K,V> eldest) 方法返回值為 true 的時候，當我們添加一個新的元素之后，afterNodeInsertion這個后置操作，將會刪除雙向鏈表最初的節點，也就是 head 節點。
• 那么我們就可以從 removeEldestEntry 方法入手來構建我們的 LruCache 。

public class LruCache<K, V> extends LinkedHashMap<K, V> {private static final int MAX_NODE_NUM = 2<<4;private int limit;public LruCache() {this(MAX_NODE_NUM);}public LruCache(int limit) {super(limit, 0.75f, true);this.limit = limit;}public V putValue(K key, V val) {return put(key, val);}public V getValue(K key) {return get(key);}/*** 判斷存儲元素個數是否預定閾值* @return 超限返回 true，否則返回 false*/@Overrideprotected boolean removeEldestEntry(Map.Entry<K, V> eldest) {return size() > limit;} }

• 我們構建了一個 LruCache 類， 他繼承自 LinkedHashMap 在構建的時候，調用了 LinkedHashMap 的三個參數的構造方法且 accessOrder 傳入 true，并覆寫了 removeEldestEntry 方法，當 Map 中的節點個數超過我們預定的閾值時候在 putValue 將會執行 afterNodeInsertion 刪除最近沒有訪問的元素。
• 測試一下

//構建一個閾值為 3 的 LruCache 類LruCache<String,Integer> lruCache = new LruCache<>(3);lruCache.putValue("老大", 1);lruCache.putValue("老二", 2);lruCache.putValue("老三", 3);lruCache.getValue("老大");//超過指定 閾值 3 再次添加元素的 將會刪除最近最少訪問的節點lruCache.putValue("老四", 4);System.out.println("lruCache = " + lruCache);

運行結果當然是刪除 key 為 “老二” 的節點：

lruCache = {老三=3, 老大=1, 老四=4}

六、 總結

LinkedHashMap 擁有與 HashMap 相同的底層哈希表結構，即數組 + 單鏈表 + 紅黑樹，也擁有相同的擴容機制。

LinkedHashMap 相比 HashMap 的拉鏈式存儲結構，內部額外通過 Entry 維護了一個雙向鏈表。

HashMap 元素的遍歷順序不一定與元素的插入順序相同，而 LinkedHashMap 則通過遍歷雙向鏈表來獲取元素，所以遍歷順序在一定條件下等于插入順序。

LinkedHashMap 可以通過構造參數 accessOrder 來指定雙向鏈表是否在元素被訪問后改變其在雙向鏈表中的位置。

1. 每次添加新節點的時候實際上是調用 newNode 方法生成了一個新的節點，LinkedHashMap 復寫了該方法，雙向鏈 表的操作一定在**linkNodeLast方法中實現**：將新的節點與之前雙向鏈表的最后一個節點（tail）建立關系，彼 此擁有指向對方的引用，這么做就能確保了雙向鏈表的元素之間的關系即為添加元素的順序。2. LinkedHashMap 刪除節點的操作，對于 afterNodeRemoval（node） HashMap 中是空實現，而該方法，正是 LinkedHashMap 刪除對應節點在雙向鏈表中的關系的操作3. LinkedHashMap 與 HashMap 添加和刪除元素的不同，可以看出除了維護 Hash表中元素的關系以外， LinkedHashMap 還在添加和刪除元素的時候維護著一個雙向鏈表。4. 該方法隨 LinkedHashMap 構造參數初始化，accessOrder 默認值為 false。--LinkedHashMap 通過 afterNodeAccess 這個**后置操作**，可以在 accessOrde = true 的時候，使雙向鏈表維護哈希表中元素的訪問順序。5. LinkedHashMap 的迭代器，由于有雙向鏈表的存在，它相比 HashMap 遍歷節點的方式更為高效--直接指向了當前 節點的 after 后驅節點

本文參考：@凱旋之戀 https://www.jianshu.com/p/1038f42b064c

總結

以上是生活随笔為你收集整理的LinkedHashMap与HashMap 关系的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。