「集合系列」- 深入淺出分析 LinkedHashMap

在上一章節，咱們深入淺出的分析了 HashMap，如果你已讀過 HashMap 的講解，一定能夠想到本文將要講解的 LinkedHashMap 其實也是一樣的，LinkedHashMap 繼承於 HashMap，不同的是 LinkedHashMap 插入的元素，可以按照插入的順序讀取！

01、摘要

在集合系列的第一章，咱們瞭解到，Map 的實現類有 HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties 等等。

本文主要從數據結構和算法層面，探討 LinkedHashMap 的實現。

02、簡介

LinkedHashMap 可以認為是 HashMap+LinkedList，它既使用 HashMap 操作數據結構，又使用 LinkedList 維護插入元素的先後順序，內部採用雙向鏈表（doubly-linked list）的形式將所有元素（ entry ）連接起來。

LinkedHashMap 繼承了 HashMap，允許放入 key 為 null 的元素，也允許插入 value 為 null 的元素。從名字上可以看出該容器是 LinkedList 和 HashMap 的混合體，也就是說它同時滿足 HashMap 和 LinkedList 的某些特性，可將 LinkedHashMap 看作採用 Linkedlist 增強的 HashMap。

打開 LinkedHashMap 源碼，可以看到主要三個核心屬性：

<code>public class LinkedHashMap    extends HashMap    implements Map{/**雙向鏈表的頭節點*/transient LinkedHashMap.Entry head;/**雙向鏈表的尾節點*/transient LinkedHashMap.Entry tail;/**  * 1、如果accessOrder為true的話，則會把訪問過的元素放在鏈表後面，放置順序是訪問的順序  * 2、如果accessOrder為false的話，則按插入順序來遍歷  */  final boolean accessOrder;}/<code>

LinkedHashMap 在初始化階段，默認按插入順序來遍歷

<code>public LinkedHashMap() {        super();        accessOrder = false;}/<code>

LinkedHashMap 採用的 Hash 算法和 HashMap 相同，不同的是，它重新定義了數組中保存的元素 Entry，該 Entry 除了保存當前對象的引用外，還保存了其上一個元素 before 和下一個元素 after 的引用，從而在哈希表的基礎上又構成了雙向鏈接列表。

源碼如下：

<code>static class Entry extends HashMap.Node {//before指的是鏈表前驅節點，after指的是鏈表後驅節點        Entry before, after;        Entry(int hash, K key, V value, Node next) {            super(hash, key, value, next);        }}/<code>

可以直觀的看出，雙向鏈表頭部插入的數據為鏈表的入口，迭代器遍歷方向是從鏈表的頭部開始到鏈表尾部結束。

除了可以保迭代歷順序，這種結構還有一個好處：迭代 LinkedHashMap 時不需要像 HashMap 那樣遍歷整個 table，而只需要直接遍歷 header 指向的雙向鏈表即可，也就是說 LinkedHashMap 的迭代時間就只跟 entry 的個數相關，而跟 table 的大小無關。

03、常用方法介紹

3.1、get方法

get 方法根據指定的 key 值返回對應的 value。該方法跟 HashMap.get() 方法的流程幾乎完全一樣，默認按照插入順序遍歷。

<code>public V get(Object key) {        Node e;        if ((e = getNode(hash(key), key)) == null)            return null;        if (accessOrder)            afterNodeAccess(e);        return e.value;}/<code>

如果accessOrder為true的話，會把訪問過的元素放在鏈表後面，放置順序是訪問的順序

<code>void afterNodeAccess(Node e) { // move node to last        LinkedHashMap.Entry last;        if (accessOrder && (last = tail) != e) {            LinkedHashMap.Entry p =                (LinkedHashMap.Entry)e, b = p.before, a = p.after;            p.after = null;            if (b == null)                head = a;            else                b.after = a;            if (a != null)                a.before = b;            else                last = b;            if (last == null)                head = p;            else {                p.before = last;                last.after = p;            }            tail = p;            ++modCount;        }}/<code>

測試用例：

<code>public static void main(String[] args) {//accessOrder默認為false        Map<string> accessOrderFalse = new LinkedHashMap<>();        accessOrderFalse.put("1","1");        accessOrderFalse.put("2","2");        accessOrderFalse.put("3","3");        accessOrderFalse.put("4","4");        System.out.println("acessOrderFalse："+accessOrderFalse.toString());//accessOrder設置為true        Map<string> accessOrderTrue = new LinkedHashMap<>(16, 0.75f, true);        accessOrderTrue.put("1","1");        accessOrderTrue.put("2","2");        accessOrderTrue.put("3","3");        accessOrderTrue.put("4","4");        accessOrderTrue.get("2");//獲取鍵2        accessOrderTrue.get("3");//獲取鍵3        System.out.println("accessOrderTrue："+accessOrderTrue.toString());}/<string>/<string>/<code>

輸出結果：

<code>acessOrderFalse：{1=1, 2=2, 3=3, 4=4}accessOrderTrue：{1=1, 4=4, 2=2, 3=3}/<code>

3.2、put方法

put(K key, V value) 方法是將指定的 key, value 對添加到 map 裡。該方法首先會調用 HashMap 的插入方法，同樣對 map 做一次查找，看是否包含該元素，如果已經包含則直接返回，查找過程類似於 get() 方法；如果沒有找到，將元素插入集合。

<code>/**HashMap 中實現*/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) {        Node[] tab; Node 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 {            Node e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;            else if (p instanceof TreeNode)                e = ((TreeNode)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);                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    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;}/<code>

LinkedHashMap 中覆寫的方法

<code>// LinkedHashMap 中覆寫Node newNode(int hash, K key, V value, Node e) {    LinkedHashMap.Entry p =        new LinkedHashMap.Entry(hash, key, value, e);    // 將 Entry 接在雙向鏈表的尾部    linkNodeLast(p);    return p;}private void linkNodeLast(LinkedHashMap.Entry p) {    LinkedHashMap.Entry last = tail;    tail = p;    // last 為 null，表明鏈表還未建立    if (last == null)        head = p;    else {        // 將新節點 p 接在鏈表尾部        p.before = last;        last.after = p;    }}/<code>

3.3、remove方法

remove(Object key) 的作用是刪除 key 值對應的 entry，該方法實現邏輯主要以 HashMap 為主，首先找到 key 值對應的 entry，然後刪除該 entry（修改鏈表的相應引用），查找過程跟 get() 方法類似，最後會調用 LinkedHashMap 中覆寫的方法，將其刪除！

<code>/**HashMap 中實現*/public V remove(Object key) {    Node e;    return (e = removeNode(hash(key), key, null, false, true)) == null ?        null : e.value;}final Node removeNode(int hash, Object key, Object value,                           boolean matchValue, boolean movable) {    Node[] tab; Node p; int n, index;    if ((tab = table) != null && (n = tab.length) > 0 &&        (p = tab[index = (n - 1) & hash]) != null) {        Node 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) {...}            else {                // 遍歷單鏈表，尋找要刪除的節點，並賦值給 node 變量                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) {...}            // 將要刪除的節點從單鏈表中移除            else if (node == p)                tab[index] = node.next;            else                p.next = node.next;            ++modCount;            --size;            afterNodeRemoval(node);    // 調用刪除回調方法進行後續操作            return node;        }    }    return null;}/<code>

LinkedHashMap 中覆寫的 afterNodeRemoval 方法

<code>void afterNodeRemoval(Node e) { // unlink    LinkedHashMap.Entry p =        (LinkedHashMap.Entry)e, b = p.before, a = p.after;    // 將 p 節點的前驅後後繼引用置空    p.before = p.after = null;    // b 為 null，表明 p 是頭節點    if (b == null)        head = a;    else        b.after = a;    // a 為 null，表明 p 是尾節點    if (a == null)        tail = b;    else        a.before = b;}/<code>

04、總結

LinkedHashMap 繼承自 HashMap，所有大部分功能特性基本相同，二者唯一的區別是 LinkedHashMap 在 HashMap 的基礎上，採用雙向鏈表（doubly-linked list）的形式將所有 entry 連接起來，這樣是為保證元素的迭代順序跟插入順序相同。

主體部分跟 HashMap 完全一樣，多了 header 指向雙向鏈表的頭部，tail 指向雙向鏈表的尾部，默認雙向鏈表的迭代順序就是 entry 的插入順序。

05、參考

1、JDK1.7&JDK1.8 源碼

2、博客園 - CarpenterLee - Java集合框架源碼剖析LinkedHashMap

閱讀更多 科技伍小黑 的文章

關鍵字: 算法 系列 數據結構