Java集合之LinkedHashMap源碼解析

時間  2019-12-08
標籤 java 集合 linkedhashmap 源碼 解析 欄目 Java 简体版
原文   原文鏈接

原文地址java

LinkedHashMap

LinkedHashMap繼承自HashMap實現了Map接口。基本實現同HashMap同樣，不一樣之處在於LinkedHashMap保證了迭代的有序性。其內部維護了一個雙向鏈表，解決了 HashMap不能隨時保持遍歷順序和插入順序一致的問題。
除此以外，LinkedHashMap對訪問順序也提供了相關支持。在一些場景下，該特性頗有用，好比緩存。node

在實現上，LinkedHashMap不少方法直接繼承自HashMap，僅爲維護雙向鏈表覆寫了部分方法。因此，要看懂 LinkedHashMap 的源碼，須要先看懂 HashMap 的源碼。segmentfault

默認狀況下，LinkedHashMap的迭代順序是按照插入節點的順序。也能夠經過改變accessOrder參數的值，使得其遍歷順序按照訪問順序輸出。緩存

這裏咱們只討論LinkedHashMap和HashMap的不一樣之處，LinkedHashMap的其餘操做和特性具體請參考HashMap的實現數據結構

咱們先來看下二者的區別：框架

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class Test04 {

    public static void main(String[] args) {
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("ahdjkf", "1");
        map.put("ifjdj", "2");
        map.put("giafdja", "3");
        map.put("agad", "4");
        map.put("ahdjkge", "5");
        map.put("iegnj", "6");

        System.out.println("LinkedHashMap的迭代順序(accessOrder=false)：");
        Iterator iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator.next();
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        
        Map<String, String> map1 = new LinkedHashMap<String, String>(16,0.75f,true);
        map1.put("ahdjkf", "1");
        map1.put("ifjdj", "2");
        map1.put("giafdja", "3");
        map1.put("agad", "4");
        map1.put("ahdjkge", "5");
        map1.put("iegnj", "6");
        
        map1.get("ahdjkf");
        map1.get("ifjdj");

        System.out.println("LinkedHashMap的迭代順序(accessOrder=true)：");
        Iterator iterator1 = map1.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry entry = (Map.Entry) iterator1.next();
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        
        Map<String, String> map2 = new HashMap<>();
        map2.put("ahdjkf", "1");
        map2.put("ifjdj", "2");
        map2.put("giafdja", "3");
        map2.put("agad", "4");
        map2.put("ahdjkge", "5");
        map2.put("iegnj", "6");
        
        System.out.println("HashMap的迭代順序：");    
        Iterator iterator2 = map2.entrySet().iterator();
        while (iterator2.hasNext()) {
            Map.Entry aMap = (Map.Entry) iterator2.next();
            System.out.println(aMap.getKey() + "=" + aMap.getValue());
        }
    }
}
Output：
LinkedHashMap的迭代順序(accessOrder=false)：
ahdjkf=1
ifjdj=2
giafdja=3
agad=4
ahdjkge=5
iegnj=6
LinkedHashMap的迭代順序(accessOrder=true)：
giafdja=3
agad=4
ahdjkge=5
iegnj=6
ahdjkf=1
ifjdj=2
HashMap的迭代順序：
iegnj=6
giafdja=3
ifjdj=2
agad=4
ahdjkf=1
ahdjkge=5

能夠看到 LinkedHashMap在每次插入數據，訪問、修改數據時都會調整鏈表的節點順序。以決定迭代時輸出的順序。優化

下面咱們來看LinkedHashMap具體是怎麼實現的：this

LinkedHashMap繼承了HashMap，內部靜態類Entry繼承了HashMap的Entry，可是LinkedHashMap.Entry多了兩個字段：before和after，before表示在本節點以前添加到LinkedHashMap的那個節點，after表示在本節點以後添加到LinkedHashMap的那個節點，這裏的以前和以後指時間上的前後順序。spa

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

同時類裏有兩個成員變量head和tail,分別指向內部雙向鏈表的表頭、表尾。code

//雙向鏈表的頭結點
transient LinkedHashMap.Entry<K,V> head;

//雙向鏈表的尾節點
transient LinkedHashMap.Entry<K,V> tail;

咱們經過兩張圖來看下LinkedHashMap的存儲結構

Imgur
Imgur

圖片來自：coolblog

將LinkedHashMap的accessOrder字段設置爲true後，每次訪問哈希表中的節點都將該節點移到鏈表的末尾，表示該節點是最新訪問的節點。即循環雙向鏈表的頭部存放的是最久訪問的節點或最早插入的節點，尾部爲最近訪問的或最近插入的節點。

因爲增長了一個accessOrder屬性，LinkedHashMap相對HashMap來講增長了一個構造方法用來控制迭代順序。

final boolean accessOrder;

public LinkedHashMap() {
    super();
    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;
}
//利用另外一個Map 來構建
public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    //該方法上文分析過，批量插入一個map中的全部數據到 本集合中。
    putMapEntries(m, false);
}

添加元素

LinkedHashMap在添加元素的時候，依舊使用的是HashMap中的put方法。不一樣的是LinkedHashMap重寫了newNode()方法在每次構建新節點時，經過linkNodeLast(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;
    }
}

刪除元素

LinkedHashMap並無重寫HashMap的remove()方法，可是他重寫了afterNodeRemoval()方法，這個方法的做用是在刪除一個節點時，同步將該節點從雙向鏈表中刪除。該方法將會在remove中被回調。

//在刪除節點e時，同步將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 的前置後置節點都置空
    p.before = p.after = null;
    //若是前置節點是null，則說明如今的頭結點應該是後置節點a
    if (b == null)
        head = a;
    else//不然將前置節點b的後置節點指向a
        b.after = a;
    //同理若是後置節點時null ，則尾節點應是b
    if (a == null)
        tail = b;
    else//不然更新後置節點a的前置節點爲b
        a.before = b;
}

刪除過程總的來講能夠分爲三步：

  1. 根據 hash 定位到桶位置
  2. 遍歷鏈表或調用紅黑樹相關的刪除方法
  3. 回調afterNodeRemoval，從 LinkedHashMap 維護的雙鏈表中移除要刪除的節點

更新元素

// 清除節點時要將頭尾節點一塊兒清除 
public void clear() {
    super.clear();
    head = tail = null;
}

查找元素

LinkedHashMap重寫了get()和getOrDefault()方法

默認狀況下，LinkedHashMap是按插入順序維護鏈表。不過若是咱們在初始化 LinkedHashMap時，指定 accessOrder參數爲 true，便可讓它按訪問順序維護鏈表。訪問順序的原理是，當咱們調用get/getOrDefault/replace等方法時，會將這些方法訪問的節點移動到鏈表的尾部。

public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    if (accessOrder)  // 回調afterNodeAccess(Node<K,V> e)
        afterNodeAccess(e);  // 將節點e移至雙向鏈表的尾部（保證迭代順序）
    return e.value;
}
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;
}

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;//原尾節點
    //若是accessOrder 是true ，且原尾節點不等於e
    if (accessOrder && (last = tail) != e) {
        //節點e強轉成雙向鏈表節點p
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        //p如今是尾節點， 後置節點必定是null
        p.after = null;
        //若是p的前置節點是null，則p之前是頭結點，因此更新如今的頭結點是p的後置節點a
        if (b == null)
            head = a;
        else//不然更新p的前直接點b的後置節點爲 a
            b.after = a;
        //若是p的後置節點不是null，則更新後置節點a的前置節點爲b
        if (a != null)
            a.before = b;
        else//若是本來p的後置節點是null，則p就是尾節點。 此時 更新last的引用爲 p的前置節點b
            last = b;
        if (last == null) //本來尾節點是null  則，鏈表中就一個節點
            head = p;
        else {//不然 更新 當前節點p的前置節點爲 原尾節點last， last的後置節點是p
            p.before = last;
            last.after = p;
        }
        //尾節點的引用賦值成p
        tail = p;
        //修改modCount。
        ++modCount;
    }
}

// 由於LinkedHashMap中維護了一個雙向鏈表因此相對於HashMap中的雙重循環遍歷這個方法要優化不少
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;
}

HashMap
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

其餘方法

LinkedHashMap還有一個比較神奇的存在。

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

// 移除最近最少被訪問條件之一，經過覆蓋此方法可實現不一樣策略的緩存
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

上面的方法通常不會被執行，可是當咱們基於 LinkedHashMap 實現緩存時，經過覆寫removeEldestEntry方法能夠實現自定義策略的 LRU 緩存。好比咱們能夠根據節點數量判斷是否移除最近最少被訪問的節點，或者根據節點的存活時間判斷是否移除該節點等。

　迭代器

public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        //返回LinkedEntrySet
        return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
    }
    final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new LinkedEntryIterator();
        }
    }
final class LinkedEntryIterator extends LinkedHashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

    abstract class LinkedHashIterator {
        //下一個節點
        LinkedHashMap.Entry<K,V> next;
        //當前節點
        LinkedHashMap.Entry<K,V> current;
        int expectedModCount;

        LinkedHashIterator() {
            //初始化時，next 爲 LinkedHashMap內部維護的雙向鏈表的扁頭
            next = head;
            //記錄當前modCount，以知足fail-fast
            expectedModCount = modCount;
            //當前節點爲null
            current = null;
        }
        //判斷是否還有next
        public final boolean hasNext() {
            //就是判斷next是否爲null，默認next是head  表頭
            return next != null;
        }
        //nextNode() 就是迭代器裏的next()方法 。
        //該方法的實現能夠看出，迭代LinkedHashMap，就是從內部維護的雙鏈表的表頭開始循環輸出。
        final LinkedHashMap.Entry<K,V> nextNode() {
            //記錄要返回的e。
            LinkedHashMap.Entry<K,V> e = next;
            //判斷fail-fast
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            //若是要返回的節點是null，異常
            if (e == null)
                throw new NoSuchElementException();
            //更新當前節點爲e
            current = e;
            //更新下一個節點是e的後置節點
            next = e.after;
            //返回e
            return e;
        }
        //刪除方法 最終仍是調用了HashMap的removeNode方法
        public final void remove() {
            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;
        }
    }

該方法的實現能夠看出，迭代LinkedHashMap，就是從內部維護的雙鏈表的表頭開始循環輸出。而雙鏈表節點的順序在LinkedHashMap的增、刪、改、查時都會更新。以知足按照插入順序輸出，仍是訪問順序輸出。

總結

總結：

在平常開發中LinkedHashMap 的使用頻率沒有HashMap高，但它也個重要的實現。

在 Java 集合框架中，HashMap、LinkedHashMap 和 TreeMap 三個映射類基於不一樣的數據結構，並實現了不一樣的功能。

HashMap 底層基於拉鍊式的散列結構，並在 JDK 1.8 中引入紅黑樹優化過長鏈表的問題。基於這樣結構，HashMap 可提供高效的增刪改查操做。

LinkedHashMap 在其之上，經過維護一條雙向鏈表，實現了散列數據結構的有序遍歷。

TreeMap 底層基於紅黑樹實現，利用紅黑樹的性質，實現了鍵值對排序功能。具體實現咱們下次分析。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程