JDK1.8源碼(九)——java.util.LinkedHashMap 類

　　前面我們介紹了 Map 集合的一種典型實現  HashMap  ，關於 HashMap 的特性，我們再來復習一遍：

　　①、基於JDK1.8的HashMap是由數組+鏈表+紅黑樹組成，相對於早期版本的 JDK HashMap 實現，新增了紅黑樹作為底層數據結構，在數據量較大且哈希碰撞較多時，能夠極大的增加檢索的效率。

　　②、允許 key 和 value 都為 null。key 重復會被覆蓋，value 允許重復。

　　③、非線程安全

　　④、無序（遍歷HashMap得到元素的順序不是按照插入的順序）

　　HashMap 集合可以說是最重要的集合之一，上篇博客介紹的 HashSet 集合就是繼承 HashMap 來實現的。而本篇博客我們介紹 Map 集合的另一種實現——LinkedHashMap，其實也是繼承 HashMap 集合來實現的，而且我們在介紹 HashMap 集合的 put 方法時，也指出了 put 方法中調用的部分方法在 HashMap 都是空實現，而在 LinkedHashMap 中進行了重寫。所以想要徹底了解 LinkedHashMap 的實現原理，HashMap 的實現原理一定不能不懂。

1、LinkedHashMap 定義

　　LinkedHashMap 是基於 HashMap 實現的一種集合，具有 HashMap 集合上面所說的所有特點，除了 HashMap 無序的特點，LinkedHashMap 是有序的，因為 LinkedHashMap 在 HashMap 的基礎上單獨維護了一個具有所有數據的雙向鏈表，該鏈表保證了元素迭代的順序。

　　所以我們可以直接這樣說：LinkedHashMap = HashMap + LinkedList。LinkedHashMap 就是在 HashMap 的基礎上多維護了一個雙向鏈表，用來保證元素迭代順序。

　　更形象化的圖形展示可以直接移到文章末尾。

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>

　　

2、字段屬性

 　　①、Entry<K,V>

    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，我們看到對於 Entry 繼承自 HashMap 的 Node 結構，相對於 Node 結構，LinkedHashMap 多了 before 和 after 結構。

　　下面是Map類集合基本元素的實現演變。

　　

　　LinkedHashMap 中 Entry 相對於 HashMap 多出的 before 和 after 便是用來維護 LinkedHashMap  插入 Entry 的先后順序的。

　　②、其它屬性

//用來指向雙向鏈表的頭節點
transient LinkedHashMap.Entry<K,V> head;
//用來指向雙向鏈表的尾節點
transient LinkedHashMap.Entry<K,V> tail;
//用來指定LinkedHashMap的迭代順序
//true 表示按照訪問順序，會把訪問過的元素放在鏈表后面，放置順序是訪問的順序
//false 表示按照插入順序遍歷
final boolean accessOrder;

 　　注意：這里有五個屬性別搞混淆的，對於 Node  next 屬性，是用來維護整個集合中 Entry 的順序。對於 Entry before，Entry after ，以及 Entry head，Entry tail，這四個屬性都是用來維護保證集合順序的鏈表，其中前兩個before和after表示某個節點的上一個節點和下一個節點，這是一個雙向鏈表。后兩個屬性 head 和 tail 分別表示這個鏈表的頭節點和尾節點。

　　PS：關於雙向鏈表的介紹，可以看這篇博客。

3、構造函數

　　①、無參構造

    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

　　調用無參的 HashMap 構造函數，具有默認初始容量（16）和加載因子（0.75）。並且設定了 accessOrder = false，表示默認按照插入順序進行遍歷。

　　②、指定初始容量

    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

　　③、指定初始容量和加載因子

    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

　　④、指定初始容量和加載因子，以及迭代規則

    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

　　⑤、構造包含指定集合中的元素

    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }

　　上面所有的構造函數默認 accessOrder = false，除了第四個構造函數能夠指定 accessOrder 的值。

4、添加元素

 　　LinkedHashMap 中是沒有 put 方法的，直接調用父類 HashMap 的 put 方法。關於 HashMap 的put 方法，可以參看我對於 HashMap 的介紹。

 　　我將方法介紹復制到下面：

    //hash(key)就是上面講的hash方法，對其進行了第一步和第二步處理
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    /**
     * 
     * @param hash 索引的位置
     * @param key  鍵
     * @param value  值
     * @param onlyIfAbsent true 表示不要更改現有值
     * @param evict false表示table處於創建模式
     * @return
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
            boolean evict) {
         Node<K,V>[] tab; Node<K,V> p; int n, i;
         //如果table為null或者長度為0，則進行初始化
         //resize()方法本來是用於擴容，由於初始化沒有實際分配空間，這里用該方法進行空間分配，后面會詳細講解該方法
         if ((tab = table) == null || (n = tab.length) == 0)
             n = (tab = resize()).length;
         //注意：這里用到了前面講解獲得key的hash碼的第三步，取模運算，下面的if-else分別是 tab[i] 為null和不為null
         if ((p = tab[i = (n - 1) & hash]) == null)
             tab[i] = newNode(hash, key, value, null);//tab[i] 為null，直接將新的key-value插入到計算的索引i位置
         else {//tab[i] 不為null，表示該位置已經有值了
             Node<K,V> e; K k;
             if (p.hash == hash &&
                 ((k = p.key) == key || (key != null && key.equals(k))))
                 e = p;//節點key已經有值了，直接用新值覆蓋
             //該鏈是紅黑樹
             else if (p instanceof TreeNode)
                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
             //該鏈是鏈表
             else {
                 for (int binCount = 0; ; ++binCount) {
                     if ((e = p.next) == null) {
                         p.next = newNode(hash, key, value, null);
                         //鏈表長度大於8，轉換成紅黑樹
                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                             treeifyBin(tab, hash);
                         break;
                     }
                     //key已經存在直接覆蓋value
                     if (e.hash == hash &&
                         ((k = e.key) == key || (key != null && key.equals(k))))
                         break;
                     p = e;
                 }
             }
             if (e != null) { // existing mapping for key
                 V oldValue = e.value;
                 if (!onlyIfAbsent || oldValue == null)
                     e.value = value;
                 afterNodeAccess(e);
                 return oldValue;
             }
         }
         ++modCount;//用作修改和新增快速失敗
         if (++size > threshold)//超過最大容量，進行擴容
             resize();
         afterNodeInsertion(evict);
         return null;
    }

 　　這里主要介紹上面方法中，為了保證 LinkedHashMap 的迭代順序，在添加元素時重寫了的4個方法，分別是第23行、31行以及53、60行代碼：

newNode(hash, key, value, null);
putTreeVal(this, tab, hash, key, value)//newTreeNode(h, k, v, xpn)
afterNodeAccess(e);
afterNodeInsertion(evict);

　　①、對於 newNode(hash,key,value,null) 方法

    HashMap.Node<K,V> newNode(int hash, K key, V value, HashMap.Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
                new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }

    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        //用臨時變量last記錄尾節點tail
        LinkedHashMap.Entry<K,V> last = tail;
        //將尾節點設為當前插入的節點p
        tail = p;
        //如果原先尾節點為null，表示當前鏈表為空
        if (last == null)
            //頭結點也為當前插入節點
            head = p;
        else {
            //原始鏈表不為空，那么將當前節點的上節點指向原始尾節點
            p.before = last;
            //原始尾節點的下一個節點指向當前插入節點
            last.after = p;
        }
    }

　　也就是說將當前添加的元素設為原始鏈表的尾節點。

　　②、對於 putTreeVal 方法

　　是在添加紅黑樹節點時的操作，LinkedHashMap 也重寫了該方法的 newTreeNode 方法：

    TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
        TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
        linkNodeLast(p);
        return p;
    }

　　也就是說上面兩個方法都是在將新添加的元素放置到鏈表的尾端，並維護鏈表節點之間的關系。　

　　③、對於 afterNodeAccess(e) 方法，在 putVal 方法中，是當添加數據鍵值對的 key 存在時，會對 value 進行替換。然后調用 afterNodeAccess(e) 方法：

    //把當前節點放到雙向鏈表的尾部
    void afterNodeAccess(HashMap.Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        //當 accessOrder = true 並且當前節點不等於尾節點tail。這里將last節點賦值為tail節點
        if (accessOrder && (last = tail) != e) {
            //記錄當前節點的上一個節點b和下一個節點a
            LinkedHashMap.Entry<K,V> p =
                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            //釋放當前節點和后一個節點的關系
            p.after = null;
            //如果當前節點的前一個節點為null
            if (b == null)
                //頭節點=當前節點的下一個節點
                head = a;
            else
                //否則b的后節點指向a
                b.after = a;
            //如果a != null
            if (a != null)
                //a的前一個節點指向b
                a.before = b;
            else
                //b設為尾節點
                last = b;
            //如果尾節點為null
            if (last == null)
                //頭節點設為p
                head = p;
            else {
                //否則將p放到雙向鏈表的最后
                p.before = last;
                last.after = p;
            }
            //將尾節點設為p
            tail = p;
            //LinkedHashMap對象操作次數+1，用於快速失敗校驗
            ++modCount;
        }
    }

　　該方法是在 accessOrder = true 並且 插入的當前節點不等於尾節點時，該方法才會生效。並且該方法的作用是將插入的節點變為尾節點，后面在get方法中也會調用。代碼實現可能有點繞，可以借助下圖來理解：

　　

 　　④、在看 afterNodeInsertion(evict) 方法

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

　　該方法用來移除最老的首節點，首先方法要能執行到if語句里面，必須 evict = true，並且 頭節點不為null，並且 removeEldestEntry(first) 返回true，這三個條件必須同時滿足，前面兩個好理解，我們看最后這個方法條件：

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

　　這就奇怪了，該方法直接返回的是 false，也就是說怎么都不會進入到 if 方法體內了，那這是這么回事呢？

　　這其實是用來實現 LRU（Least Recently Used，最近最少使用）Cache 時，重寫的一個方法。比如在 mybatis-connector 包中，有這樣一個類：

package com.mysql.jdbc.util;

import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = 1L;
    protected int maxElements;

    public LRUCache(int maxSize) {
        super(maxSize, 0.75F, true);
        this.maxElements = maxSize;
    }

    protected boolean removeEldestEntry(Entry<K, V> eldest) {
        return this.size() > this.maxElements;
    }
}

　　可以看到，它重寫了 removeEldestEntry(Entry<K,V> eldest) 方法，當元素的個數大於設定的最大個數，便移除首元素。

5、刪除元素

 　　同理也是調用 HashMap 的remove 方法，這里我不作過多的講解，着重看LinkedHashMap 重寫的第 46 行方法。

public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
    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;
        //(n - 1) & hash找到桶的位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        //如果鍵的值與鏈表第一個節點相等，則將 node 指向該節點
        if (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);
        }
        }
        //刪除節點，並進行調節紅黑樹平衡
        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;
        else
         p.next = node.next;
        ++modCount;
        --size;
        afterNodeRemoval(node);
        return node;
        }
        }
        return null;
    }

　　我們看第 46 行代碼實現：

    void afterNodeRemoval(HashMap.Node<K,V> e) { // unlink
        LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.before = p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
    }

　　該方法其實很好理解，就是當我們刪除某個節點時，為了保證鏈表還是有序的，那么必須維護其前后節點。而該方法的作用就是維護刪除節點的前后節點關系。

6、查找元素

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

　　相比於 HashMap 的 get 方法，這里多出了第 5,6行代碼，當 accessOrder = true 時，即表示按照最近訪問的迭代順序，會將訪問過的元素放在鏈表后面。

　　對於 afterNodeAccess(e) 方法，在前面第 4 小節 添加元素已經介紹過了，這就不在介紹。

7、遍歷元素

　　在介紹 HashMap 時，我們介紹了 4 中遍歷方式，同理，對於 LinkedHashMap 也有 4 種，這里我們介紹效率較高的兩種遍歷方式：

　　①、得到 Entry 集合，然后遍歷 Entry

        LinkedHashMap<String,String> map = new LinkedHashMap<>();
        map.put("A","1");
        map.put("B","2");
        map.put("C","3");
        map.get("B");
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for(Map.Entry<String,String> entry : entrySet ){
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }

　　②、迭代

        Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<String,String> entry = iterator.next();
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }

　　這兩種效率都還不錯，通過迭代的方式可以對一邊遍歷一邊刪除元素，而第一種刪除元素會報錯。

　　打印結果：

　　

8、迭代器

 　　我們把上面遍歷的LinkedHashMap 構造函數改成下面的：

LinkedHashMap<String,String> map = new LinkedHashMap<>(16,0.75F,true);

　　也就是說將 accessOrder = true，表示按照訪問順序來遍歷，注意看上面的 第 5 行代碼：map.get("B)。也就是說設置 accessOrder = true 之后，那么 B---2 應該是最后輸出，我們看一下打印結果：

　　

　　結果跟預期一致。那么在遍歷的過程中，LinkedHashMap 是如何進行的呢？

　　我們追溯源碼：首先進入到 map.entrySet() 方法里面：

　　

　　發現 entrySet = new LinkedEntrySet() ，接下來我們查看 LinkedEntrySet 類。

　　

　　這是一個內部類，我們查看其 iterator() 方法，發現又new 了一個新對象 LinkedEntryIterator，接着看這個類：

　　

　　這個類繼承 LinkedHashIterator。

    abstract class LinkedHashIterator {
        LinkedHashMap.Entry<K,V> next;
        LinkedHashMap.Entry<K,V> current;
        int expectedModCount;

        LinkedHashIterator() {
            next = head;
            expectedModCount = modCount;
            current = null;
        }

        public final boolean hasNext() {
            return next != null;
        }

        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;
            next = e.after;
            return e;
        }

        public final void remove() {
            HashMap.Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }

　　看到 nextNode() 方法，很顯然是通過遍歷鏈表的方式來遍歷整個 LinkedHashMap 。

9、總結

　　通過上面的介紹，關於 LinkedHashMap ，我想直接用下面一幅圖來解釋：

　　

 

　　去掉紅色和藍色的虛線指針，其實就是一個HashMap。