歡迎關注我的公眾號“彤哥讀原始碼”，檢視更多原始碼系列文章, 與彤哥一起暢遊原始碼的海洋。
簡介
LinkedHashMap內部維護了一個雙向連結串列，能保證元素按插入的順序訪問，也能以訪問順序訪問，可以用來實現LRU快取策略。
LinkedHashMap可以看成是 LinkedList + HashMap。
繼承體系
LinkedHashMap繼承HashMap，擁有HashMap的所有特性，並且額外增加的按一定順序訪問的特性。
儲存結構
我們知道HashMap使用（陣列 + 單連結串列 + 紅黑樹）的儲存結構，那LinkedHashMap是怎麼儲存的呢？
通過上面的繼承體系，我們知道它繼承了Map，所以它的內部也有這三種結構，但是它還額外新增了一種“雙向連結串列”的結構儲存所有元素的順序。
新增刪除元素的時候需要同時維護在HashMap中的儲存，也要維護在LinkedList中的儲存，所以效能上來說會比HashMap稍慢。
原始碼解析
屬性
/**
* 雙向連結串列頭節點
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* 雙向連結串列尾節點
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* 是否按訪問順序排序
*/
final boolean accessOrder;
複製程式碼（1）head
雙向連結串列的頭節點，舊資料存在頭節點。
（2）tail
雙向連結串列的尾節點，新資料存在尾節點。
（3）accessOrder
是否需要按訪問順序排序，如果為false則按插入順序儲存元素，如果是true則按訪問順序儲存元素。
內部類
// 位於LinkedHashMap中
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);
}
}
// 位於HashMap中
static class Node<K, V> implements Map.Entry<K, V> {
final int hash;
final K key;
V value;
Node<K, V> next;
}
複製程式碼儲存節點，繼承自HashMap的Node類，next用於單連結串列儲存於桶中，before和after用於雙向連結串列儲存所有元素。
構造方法
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);
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
複製程式碼前四個構造方法accessOrder都等於false，說明雙向連結串列是按插入順序儲存元素。
最後一個構造方法accessOrder從構造方法引數傳入，如果傳入true，則就實現了按訪問順序儲存元素，這也是實現LRU快取策略的關鍵。
afterNodeInsertion(boolean evict)方法
在節點插入之後做些什麼，在HashMap中的putVal()方法中被呼叫，可以看到HashMap中這個方法的實現為空。
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
複製程式碼evict，驅逐的意思。
（1）如果evict為true，且頭節點不為空，且確定移除最老的元素，那麼就呼叫HashMap.removeNode()把頭節點移除（這裡的頭節點是雙向連結串列的頭節點，而不是某個桶中的第一個元素）；
（2）HashMap.removeNode()從HashMap中把這個節點移除之後，會呼叫afterNodeRemoval()方法；
（3）afterNodeRemoval()方法在LinkedHashMap中也有實現，用來在移除元素後修改雙向連結串列，見下文；
（4）預設removeEldestEntry()方法返回false，也就是不刪除元素。
afterNodeAccess(Node<K,V> e)方法
在節點訪問之後被呼叫，主要在put()已經存在的元素或get()時被呼叫，如果accessOrder為true，呼叫這個方法把訪問到的節點移動到雙向連結串列的末尾。
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
// 如果accessOrder為true，並且訪問的節點不是尾節點
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 把p節點從雙向連結串列中移除
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
// 把p節點放到雙向連結串列的末尾
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
// 尾節點等於p
tail = p;
++modCount;
}
}
複製程式碼（1）如果accessOrder為true，並且訪問的節點不是尾節點；
（2）從雙向連結串列中移除訪問的節點；
（3）把訪問的節點加到雙向連結串列的末尾；（末尾為最新訪問的元素）
afterNodeRemoval(Node<K,V> e)方法
在節點被刪除之後呼叫的方法。
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 把節點p從雙向連結串列中刪除。
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
複製程式碼經典的把節點從雙向連結串列中刪除的方法。
get(Object key)方法
獲取元素。
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
複製程式碼如果查詢到了元素，且accessOrder為true，則呼叫afterNodeAccess()方法把訪問的節點移到雙向連結串列的末尾。
總結
（1）LinkedHashMap繼承自HashMap，具有HashMap的所有特性；
（2）LinkedHashMap內部維護了一個雙向連結串列儲存所有的元素；
（3）如果accessOrder為false，則可以按插入元素的順序遍歷元素；
（4）如果accessOrder為true，則可以按訪問元素的順序遍歷元素；
（5）LinkedHashMap的實現非常精妙，很多方法都是在HashMap中留的鉤子（Hook），直接實現這些Hook就可以實現對應的功能了，並不需要再重寫put()等方法；
（6）預設的LinkedHashMap並不會移除舊元素，如果需要移除舊元素，則需要重寫removeEldestEntry()方法設定移除策略；
（7）LinkedHashMap可以用來實現LRU快取淘汰策略；
彩蛋
LinkedHashMap如何實現LRU快取淘汰策略呢？
首先，我們先來看看LRU是個什麼鬼。LRU，Least Recently Used，最近最少使用，也就是優先淘汰最近最少使用的元素。
如果使用LinkedHashMap，我們把accessOrder設定為true是不是就差不多能實現這個策略了呢？答案是肯定的。請看下面的程式碼：
package com.coolcoding.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author: tangtong
* @date: 2019/3/18
*/
public class LRUTest {
public static void main(String[] args) {
// 建立一個只有5個元素的快取
LRU<Integer, Integer> lru = new LRU<>(5, 0.75f);
lru.put(1, 1);
lru.put(2, 2);
lru.put(3, 3);
lru.put(4, 4);
lru.put(5, 5);
lru.put(6, 6);
lru.put(7, 7);
System.out.println(lru.get(4));
lru.put(6, 666);
// 輸出: {3=3, 5=5, 7=7, 4=4, 6=666}
// 可以看到最舊的元素被刪除了
// 且最近訪問的4被移到了後面
System.out.println(lru);
}
}
class LRU<K, V> extends LinkedHashMap<K, V> {
// 儲存快取的容量
private int capacity;
public LRU(int capacity, float loadFactor) {
super(capacity, loadFactor, true);
this.capacity = capacity;
}
/**
* 重寫removeEldestEntry()方法設定何時移除舊元素
* @param eldest
* @return
*/
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
// 當元素個數大於了快取的容量, 就移除元素
return size() > this.capacity;
}
}
複製程式碼歡迎關注我的公眾號“彤哥讀原始碼”，檢視更多原始碼系列文章, 與彤哥一起暢遊原始碼的海洋。
