Java 中最大的數據結構：LinkedHashMap 瞭解一下？

時間 2019-11-24

標籤 java 最大數據結構 linkedhashmap 瞭解一下欄目 Java 简体版

原文原文鏈接

前言

Map 家族數量衆多，其中 HashMap 和 ConcurrentHashMap 用的最多，而 LinkedHashMap 彷佛則是不怎麼用的，可是他卻有着順序。兩種，一種是添加順序，一種是訪問順序。java

詳情

LinkedHashMap 繼承了 HashMap。那麼若是是你，你怎麼實現這兩個順序呢？node

若是實現添加順序的話，咱們能夠在該類中，增長一個鏈表，每一個節點對應 hash 表中的桶。這樣，循環遍歷的時候，就能夠按照鏈表遍歷了。只是會增大內存消耗。算法

若是實現訪問順序的話，一樣也可使用鏈表，但每次讀取數據時，都須要更新一下鏈表，將最近一次讀取的放到鏈尾。這樣也就可以實現。此時也能夠跟進這個特性實現 LRU（Least Recently Used）緩存。緩存

如何使用？

下面是個小 demo安全

LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(16, 0.75f, true);
for (int i = 0; i < 10; i++) {
  map.put(i, i);
}

for (Map.Entry entry : map.entrySet()) {
  System.out.println(entry.getKey() + ":" + entry.getValue());
}
map.get(3);
System.out.println();
for (Map.Entry entry : map.entrySet()) {
  System.out.println(entry.getKey() + ":" + entry.getValue());
}
複製代碼

打印結果：併發

0:0
1:1
2:2
3:3
4:4
5:5
6:6
7:7
8:8
9:9

0:0
1:1
2:2
4:4
5:5
6:6
7:7
8:8
9:9
3:3
複製代碼

首先構造方法是有意思的，比 HashMap 多了一個 accessOrder boolean 參數。表示，按照訪問順序來排序。最新訪問的放在鏈表尾部。性能

若是是默認的，則是按照添加順序，即 accessOrder 默認是 false。spa

源碼實現

若是看 LinkedHashMap 內部源碼，會發現，內部確實維護了一個鏈表：code

/** * 雙向鏈表的頭，最久訪問的 */
    transient LinkedHashMap.Entry<K,V> head;

    /** * 雙向鏈表的尾，最新訪問的 */
    transient LinkedHashMap.Entry<K,V> tail;
複製代碼

而這個 LinkedHashMap.Entry 內部也維護了雙向鏈表必須的元素，before，after：orm

/** * HashMap.Node subclass for normal LinkedHashMap entries. */
    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);
        }
    }
複製代碼

在添加元素的時候，會追加到尾部。

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

    // link at the end of list
    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;
        }
    }
複製代碼

在 get 的時候，會根據 accessOrder 屬性，修改鏈表順序：

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

    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)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;
        }
    }
複製代碼

同時注意：這裏修改了 modCount，即便是讀操做，併發也是不安全的。

如何實現 LRU 緩存？

LRU 緩存：LRU（Least Recently Used，最近最少使用）算法根據數據的歷史訪問記錄來進行淘汰數據，其核心思想是「若是數據最近被訪問過，那麼未來被訪問的概率也更高」。

LinkedHashMap 並無幫我咱們實現具體，須要咱們本身實現。具體實現方法是 removeEldestEntry 方法。

一塊兒來看看原理。

首先，HashMap 在 putVal 方法最後，會調用 afterNodeInsertion 方法，其實就是留給 LinkedHashMap 的。而 LinkedHashMap 的具體實現則是根據一些條件，判斷是否須要刪除 head 節點。

源碼以下：

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);
        }
    }
複製代碼

evict 參數表示是否須要刪除某個元素，而這個 if 判斷須要知足的條件如上：head 不能是 null，調用 removeEldestEntry 方法，返回 true 的話，就刪除這個 head。而這個方法默認是返回 false 的，等待着你來重寫。

因此，removeEldestEntry 方法的實現一般是這樣：

public boolean removeEldestEntry(Map.Entry<K, V> eldest){    
   return size() > capacity;  
} 
複製代碼

若是長度大於容量了，那麼就須要清除不常常訪問的緩存了。afterNodeInsertion 會調用 removeNode 方法，刪除掉 head 節點 —— 若是 accessOrder 是 true 的話，這個節點就是最不常常訪問的節點。

拾遺

LinkedHashMap 重寫了一些 HashMap 的方法，例如 containsValue 方法，這個方法你們猜一猜，怎麼重寫比較合理？

HashMap 使用了雙重循環，先循環外層的 hash 表，再循環內層的 entry 鏈表。性能可想而知。

但 LinkedHashMap 內部有個元素鏈表，直接遍歷鏈表就行。相對而言而高不少。

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;
    }
複製代碼