LinkedHashMap源碼__java

LinkedHashMap繼承了HashMap,HashMap具有的特性LinkedHashMap也有。

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

LinkedHashMap與HashMap不同的是，除了擁有與HashMap一樣的儲存結構之外，又額外維護了一個雙向鏈表，預設按照插入順序排列，也可以通過設定accessOrder欄位實現LRU演算法，此時按照訪問順序對節點排列。

1.LinkedHashMap的儲存結構Entry

   Entry繼承了HashMap的Node，並且多出了兩個欄位before和after，這兩個欄位在構造雙向鏈表時使用

/**     * linkedHashMap的儲存結構，繼承了HashMap的Node     */    static class Entry<K,V> extends HashMap.Node<K,V> {        //比HashMap多出了兩個成員變數before和after，構造雙向鏈表使用，before指向當前節點在雙向鏈表中的前一個節點，after指向後一個節點        Entry<K,V> before, after;        Entry(int hash, K key, V value, Node<K,V> next) {            //調用Node中的建構函式執行個體化對象            super(hash, key, value, next);        }    }

2.欄位

（1）雙向鏈表有一個頭結點head和尾節點tail

（2）accessOrder為true的時候表示雙向鏈表按照訪問順序排列，為false表示按照插入順序排列。

 private static final long serialVersionUID = 3801124242820219131L;    /**     * 雙向鏈表的頭結點     */    transient LinkedHashMap.Entry<K,V> head;    /**     * 雙向鏈表的尾節點     */    transient LinkedHashMap.Entry<K,V> tail;    /**     * true表示雙向鏈表按照訪問的順序來排列，false則表示按照插入順序來排列     */    final boolean accessOrder;

3.建構函式

（1）由於LinkedHashMap繼承了HashMap,因此預設容量和載入因子與HashMap一致。

（2）需要實現LRU演算法時，需要使用 public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)建構函式，將accessOrder設為true。

/**     * 帶有指定容量的建構函式     */    public LinkedHashMap(int initialCapacity) {        super(initialCapacity);        accessOrder = false;    }    /**     * 無參建構函式，使用預設容量16和預設載入因子0.75     */    public LinkedHashMap() {        super();        accessOrder = false;    }    /**     * 建構函式     */    public LinkedHashMap(Map<? extends K, ? extends V> m) {        super();        accessOrder = false;        putMapEntries(m, false);    }    /**     * 建構函式，帶有初始容量、載入因子和accessOrder     * accessOrder：true表示鏈表按照訪問的順序來排列，false則表示按照插入順序來排列     */    public LinkedHashMap(int initialCapacity,                         float loadFactor,                         boolean accessOrder) {        super(initialCapacity, loadFactor);        this.accessOrder = accessOrder;    }

4.LRU演算法的實現

LinkedHashMap中並沒有重寫添加方法，而是直接使用了HashMap中的添加方法，但是重寫了建立新節點的newNode方法：

 /**     * 添加     *     * @param hash key的hash值     * @param key key值     * @param value value值     * @param onlyIfAbsent 如果已經存在包含key值的對象，onlyIfAbsent為true時不更新該對象的value，否則將更新為新的value     * @param evict if false, the table is in creation mode.     * @return previous value, or null if none     */    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;        //根據hash計算在數組中的索引，並擷取該索引處的對象，如果為空白，建立節點，放到該索引處        if ((p = tab[i = (n - 1) & hash]) == null)            //建立新節點，放到索引為i的位置            tab[i] = newNode(hash, key, value, null);        else {            //如果索引處已經存在節點            Node<K,V> e; K k;            //判斷該節點的hash以及key值是否與要添加的對象的key相等            if (p.hash == hash &&                    ((k = p.key) == key || (key != null && key.equals(k))))                //將第一個節點賦值給e，稍後更新e的value為新的value（根據onlyIfAbsent判斷）                e = p;            else if (p instanceof TreeNode)                //如果是紅/黑樹狀結構                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);            else {                //從鏈表中尋找，如果尋找為空白就將新節點從尾部添加（尾插法），如果根據hash和key在鏈表中查到，中斷迴圈                for (int binCount = 0; ; ++binCount) {                    //如果當前節點的下一個節點為空白                    if ((e = p.next) == null) {                        //建立新的節點，連結到當前節點                        p.next = newNode(hash, key, value, null);                        //如果節點數超過了樹化的閾值                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            //將鏈錶轉為樹                            treeifyBin(tab, hash);                        break;                    }                    //判斷節點的hash以及key值是否與要添加的對象的key相等，中斷尋找                    if (e.hash == hash &&                            ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    p = e;                }            }            if (e != null) {                //擷取舊的value                V oldValue = e.value;                //如果onlyIfAbsent為false或者舊的value是空，更新為新的value                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;        //如果長度超過了閾值        if (++size > threshold)            //調整大小            resize();        afterNodeInsertion(evict);        return null;    }

newNode方法：

可以看到建立的是Entry節點，將節點添加到雙向鏈表中並返回。

   /**     * 建立新的Node節點     * @param hash     * @param key     * @param value     * @param e     * @return     */    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);        //新節點連結尾插法插入鏈表        linkNodeLast(p);        return p;    }    /**     * 在雙向鏈表中使用尾插法插入節點     * @param p     */    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;        }    }

在添加節點時如果節點已經存，在更新節點的value後會調用afterNodeAccess(e)方法，在HashMap中此方法什麼也沒有做，在LinkedHashMap中對方法進行了重寫，將當前節點放入到雙向鏈表的尾部：

/**     * 該方法提供了LRU演算法的實現，它將最近使用的節點放到雙向迴圈鏈表的尾部     * @param e 要放到鏈表尾部的節點     */    void afterNodeAccess(Node<K,V> e) { // move node to last        LinkedHashMap.Entry<K,V> last;        //如果accessOrder為true並且當前節點不是尾節點        if (accessOrder && (last = tail) != e) {            // e=p，代表要放到鏈表尾部的節點，b為它前一個節點，a為它指向的下一個節點            LinkedHashMap.Entry<K,V> p =                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;            //將p的after設為null            p.after = null;            //如果p的一前個節點為空白，說明p是頭結點            if (b == null)                //將頭結點設為p的下一個節點a                head = a;            else                //將p前一個節點的after指向a                b.after = a;            //如果p的後一個節點不為空白            if (a != null)                //將a的前一個節點指向p的前一個節點b                a.before = b;            else                //如果p的後一個節點為空白，將p的前一個節點先當做尾節點                last = b;            //如果尾節點為空白            if (last == null)                //頭結點                head = p;            else {                //將p的前一個節點指向尾節點                p.before = last;                // 原來的尾節點的下一個節點指向p                last.after = p;            }            //設定p為尾節點            tail = p;            ++modCount;        }    }

如果是建立新的節點，在方法的最後會調用afterNodeInsertion(evict)方法，HashMap中該方法同樣什麼也不做，LinkedHashMap重寫了該方法，該方法是在實現LRU演算法時刪除最不經常使用的節點，雙向鏈表中使用的是尾插法，因此多次操作後鏈表最前面的節點被認為是最近沒有使用的：

   /**     * 刪除最老的Entry     * 因為添加節點採用的尾插法，多次操作後，雙向鏈表前面的Entry便是最近沒有使用的     * 如果實現LRU，需要重寫removeEldestEntry方法，不然只會返回false不會刪除節點     * @param 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);        }    }

在實現LRU演算法時一般也需要重寫removeEldestEntry方法，否則該方法用於返回的false，將不會刪除節點：

  /**     * 是否移除最老的Entry     * 如果實現LRU，需要重寫removeEldestEntry方法     */    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {        return false;    }

5.containsValue、get方法

（1）containsValue直接從雙向鏈表中尋找，而不用遍曆整個雜湊表，提高了效率。

（2）通過key尋找的方法還是從雜湊表中尋找，因為根據key可以直接定位到在hash表的索引。

（3）調用get擷取對象時，如果accessOrder為true同樣會調用afterNodeAccess方法，實現LRU。

    /**     * 從雙向鏈表中根據value尋找對象     */    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;    }    /**     * 根據key擷取對象，當尋找為null時返回null     */    public V get(Object key) {        Node<K,V> e;        //根據key的hash值尋找對象，如果為空白返回null        if ((e = getNode(hash(key), key)) == null)            return null;        //如果鏈表中元素的定序是按照訪問的先後順序排序，將e連結到尾節點        if (accessOrder)            afterNodeAccess(e);        return e.value;    }    /**     * 根據key擷取對象，當尋找為null時返回預設的值defaultValue     */    public V getOrDefault(Object key, V defaultValue) {        Node<K,V> e;        if ((e = getNode(hash(key), key)) == null)            return defaultValue;        if (accessOrder)            afterNodeAccess(e);        return e.value;    }

6.刪除方法

LinkedHashMap使用HashMap中的刪除方法，但是重寫了afterNodeRemoval方法。

HashMap的刪除方法：

 /**     *  根據key刪除節點     *     * @param hash hash for key     * @param key the key     * @param value the value to match if matchValue, else ignored     * @param matchValue if true only remove if value is equal     * @param movable if false do not move other nodes while removing     * @return the node, or null if none     */    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;        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;            //如果要刪除的節點在頭結點            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]位置的元素，將該節點的下一個節點放到table[index]處                    tab[index] = node.next;                else                    //如果要刪除的節點在鏈表中，記錄要刪除節點的前一個節點，將該節點的next執行要刪除節點的下一個節點                    p.next = node.next;                ++modCount;                //更改大小                --size;                afterNodeRemoval(node);                return node;            }        }        return null;    }

linkedHashMap的afterNodeRemoval方法：

    /**     * 將節點從雙向鏈表中移除     * @param 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.before = p.after = null;        if (b == null)            head = a;        else            b.after = a;        if (a == null)            tail = b;        else            a.before = b;    }

清空方法：

   /**     * 清空，直接將頭結點和尾節點設為null     */    public void clear() {        super.clear();        head = tail = null;    }

參考：

【Java集合源碼剖析】LinkedHashmap源碼剖析 【JDK1.8】JDK1.8集合源碼閱讀——LinkedHashMap Map 綜述（二）：徹頭徹尾理解 LinkedHashMap
Java集合之LinkedHashMap