HashMap 有一個不足之處就是在迭代元素時與插入順序不一致。而大多數人都喜歡按順序做某些事情，所以，LinkedHashMap 就是針對這一點對 HashMap 進行擴展，主要新增了「兩種迭代方式」：
- 按插入順序 - 保證迭代元素的順序與插入順序一致
- 按訪問順序 - 一種特殊的迭代順序，從最近最少訪問到最多訪問的元素訪問順序，非常適合構建 LRU 緩存
LinkedHashMap 的重點就是這兩點，搞清楚了，也就掌握了。由於它繼承自 HashMap，所以在分析源碼之前一定要先看看 HashMap 的源碼，可查看此文《深入分析 JDK8 中 HashMap 的原理、實現和優化》。
在 JDK 8 中，因為 LinkedHashMap 子類的存在，HashMap 引入的紅黑樹，在普通模式和樹模式之間的轉換變得復雜，那么它是如何設計和簡化的呢？接下來看看 JDK 8 中的 LinkedHashMap 源碼的設計和實現。
1. 按插入順序迭代
HashMap 為什么在迭代時就雜亂無章了？看下它在迭代時獲取下一個元素的方式，你就明白了：
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();
// 首先迭代自身所在鏈表
if ((next = (current = e).next) == null && (t = table) != null) {
// 如果鏈表訪問結束，遍歷哈希桶數組中下一個非空元素
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
可以看到，HashMap 是按照哈希桶數組中非空的槽依次遍歷的，再加上哈希沖突（鏈表）的情況，與插入順序相比，更加亂了。
那 LinkedHashMap 怎么解決的？它維護了一個貫穿所有元素的雙向鏈表，遍歷時，迭代器直接對雙向鏈表進行迭代，從而保證了與插入順序一致，關鍵成員屬性和節點信息定義如下：
// 雙向鏈表頭節點，也是最久沒有訪問的元素
transient LinkedHashMap.Entry<K,V> head;
// 雙向鏈表尾節點，也是最近剛剛訪問的元素
transient LinkedHashMap.Entry<K,V> tail;
// 迭代方式，true-按訪問順序迭代，false-按插入順序迭代，默認 false
final boolean accessOrder;
// 添加了構建雙向鏈表的前驅和后繼指針
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 在元素插入、刪除和訪問時定義並調用了一些 Hook 方法，這些方法使得 LinkedHashMap 內部保持有序的機制相對獨立，降低了普通模式和樹模式轉換的復雜度。
此外，紅黑樹節點繼承的是 LinkedHashMap 的 Entry，固然可能多了兩個指針，但在實現時有助於避免操作指針出現混淆錯誤。
LinkedHashMap 在元素插入時，覆蓋的回調方法主要有 newNode, replacementNode, replacementTreeNode, newTreeNode，主要就是保持雙向鏈表，核心是下面兩個方法：
// 插入到雙向鏈表的尾部
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail; // 臨時記住尾節點
tail = p; // 將尾指針指向新節點
if (last == null)
head = p; // 第一個插入的節點
else { // 關聯前后節點
p.before = last;
last.after = p;
}
}
// 連接兩個節點之間的前后指針
private void transferLinks(LinkedHashMap.Entry<K,V> src,
LinkedHashMap.Entry<K,V> dst) {
LinkedHashMap.Entry<K,V> b = dst.before = src.before;
LinkedHashMap.Entry<K,V> a = dst.after = src.after;
if (b == null)
head = dst;
else
b.after = dst;
if (a == null)
tail = dst;
else
a.before = dst;
}
迭代器的實現就比較簡單了，直接對這個雙向鏈表迭代即可，此時的迭代順序就插入順序。
2. 按訪問順序迭代
為了讓元素按訪問順序排列，HashMap 定義了以下 Hook 方法，供 LinkedHashMap 實現：
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
各個方法實現的原理如下：
- afterNodeAccess 的原理是：訪問的元素如果不是尾節點，那么就把它與尾節點交換，所以隨着元素的訪問，訪問次數越多的元素越靠后
- afterNodeRemoval 這個沒有特殊操作，正常的斷開鏈條
- afterNodeInsertion 的原理是：元素插入后，可能會刪除最舊的、訪問次數最少的元素，也就是頭節點
重點看下插入之后的實現：
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);
}
}
是否會刪除頭節點，是由 removeEldestEntry 方法決定的，默認返回 false。在覆蓋這個方法時，不能簡單的返回 true，因為這樣可能會導致一個空的 LinkedHashMap，通常的做法是在插入指定數量的元素后再刪除，具體見下面 LRU 緩存的實現。
3. 實現一個 LRU 緩存
借助 LinkedHashMap 可以很方便的實現一個 LRU 緩存數據結構，只需設置 accessOrder 為 true，並覆蓋 removeEldestEntry 方法即可，代碼如下：
final int MAX_CACHE_SIZE = 100;
LinkedHashMap<Object, Object> lru = new LinkedHashMap<Object, Object>(MAX_CACHE_SIZE, 0.75f, true) {
private static final long serialVersionUID = 1L;
protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
return size() > MAX_CACHE_SIZE;
}
};
4. 小結
LinkedHashMap 代碼比較簡單，難的都被 HashMap 實現了:)，它們的異同點分別如下：
- 底層都是數組+鏈表+紅黑樹（廢話）
- 迭代器都是快速失敗的，都是非線程安全
- LinkedHashMap 有按插入和訪問兩種迭代順序，而HashMap 亂序，迭代順序不可預測
看這個類的源碼，最主要的還是看 HashMap 定義 Hook 方法，使得 LinkedHashMap 保持有序的機制相對獨立的設計，這是模板模式的應用。