Java8 一篇文章徹底弄清楚HashMap底層實現

HashMap的特點

• 不允許重複的key，支持Null值和Null鍵（Null鍵會被放在第一位）
• 元素是無序的-不能保證存儲順序
• 是線程不安全的（存在高併發問題）
• 性能較高

Java8HashMap採用的是數組+鏈表+紅黑樹的數據結構 ，結構如下

繼承和實現情況

   HashMap實現了Map<K,V>, Cloneable, Serializable接口，並繼承AbstractMap<K,V>類

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    private static final long serialVersionUID = 362498820763181265L;

 成員變量

   主要包含一些字段和常量

 /* ---------------- 常量 -------------- */
    /**
     * 默認的初始容量(2的4次方)-是2冪次方
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量爲2的30次方
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 默認的負載因子，如果沒有指定的話就使用0.75
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 當鏈表元素達到8個的時候從鏈表結構變成紅黑樹結構
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 存儲計數閾值，用於在存儲期間取消(分割)存儲
     * 調整操作。應該小於TREEIFY_THRESHOLD，在大多數6網孔與收縮檢測下去除。
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 容器可能被treeified的最小表容量。(否則，如果容器中有太多節點，就會調整表的大小。)
     * 應該至少4 * TREEIFY_THRESHOLD以避免衝突在大小調整和樹化閾值之間。
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

 /* ---------------- 字段 -------------- */

    /**
     * 具體存儲數據的地方
     */
    transient Node<K,V>[] table;

    /**
     * entrySet()方法中的數據
     */
    transient Set<Map.Entry<K,V>> entrySet;

    /** 
     * 實際存儲的key-value鍵值對的個數
     */
    transient int size;

    /**
     * 這個HashMap在結構上被修改的次數
     * 結構修改是指改變映射的數量
     * HashMap或修改其內部結構(例如，重新哈希)。的集合視圖上的迭代器
     * HashMap很快失敗。(見ConcurrentModificationException)。
     */
    transient int modCount;

    /**
     * 閾值，當table == {}時，該值爲初始容量（初始容量默認爲16）；當table被填充了，也就是爲
     * table分配內存空間後，threshold一般爲 capacity*loadFactory
     */
    int threshold;

    /**
     * 負載因子，代表了table的填充度有多少，默認是0.75
     */
    final float loadFactor;

構造函數 

   //默認構造，所有的字段都是使用默認值
   //負載因子默認值0.75
   //容量默認值16
   public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    //指定容量-    
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    //指定容量和負載因子 
    public HashMap(int initialCapacity, float loadFactor) {
        //參數校驗
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        //超過容量最大值就指定爲容量最大值(2的30次方)
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //負載因子校驗
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        //初始化閾值
        this.threshold = tableSizeFor(initialCapacity);
    }
         /**
          * 返回一個2的冪次方且最接近並大於給定容量
          * 比如給定 給定13，那得出的值應該是2的4次方=16
         */
        static final int tableSizeFor(int cap) {
            int n = cap - 1;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
        }
    //給定一個集合
    public HashMap(Map<? extends K, ? extends V> m) {
        //使用默認字段構造HashMap
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        //將集合中的元素放在新的map中
        putMapEntries(m, false);
    }
        //將元素全部放在新生成的map中
        final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
            int s = m.size();
            //元素個數大於才需要進行put操作
            if (s > 0) {
                //如果table是空，需要計算負載因子和閾值
                if (table == null) { // pre-size
                    float ft = ((float)s / loadFactor) + 1.0F;
                    int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                             (int)ft : MAXIMUM_CAPACITY);
                    if (t > threshold)
                        threshold = tableSizeFor(t);
                }
                //如果給定的map的size大於閾值，需要對新的map進行擴容
                else if (s > threshold)
                    resize();
                //循環獲取數據並拷貝到新map中
                for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                    K key = e.getKey();
                    V value = e.getValue();
                    putVal(hash(key), key, value, false, evict);
                }
         }
    }

擴容函數：resize（） 

•  該方法主要是在初始化數組和數組擴容的時候使用，如果是擴容的話大多數情況是擴容爲原容量的2倍(如果擴容到最大值，以後就不在需要擴容)
• 有數據的時候需要完成數據的遷移

 //主要進行map的擴容
    final Node<K, V>[] resize() {
        // 定義舊的table保存當前table
        Node<K, V>[] oldTab = table;
        // 定義舊的容量保存當前table的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 定義舊的閾值保存當前閾值
        int oldThr = threshold;

        // 初始化新的table容量和閾值
        int newCap, newThr = 0;

        //1.如果舊的容量>0(說明是需要擴容的-舊的容量大於最的容量就直接擴容到最大整型，否則容量翻倍)
        if (oldCap > 0) {
            // 若舊table容量已超過最大容量，更新閾值爲Integer.MAX_VALUE（最大整形值），
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;            //這樣以後就不會自動擴容了
            }
            // 容量翻倍，使用左移，效率更高
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 閾值翻倍
                newThr = oldThr << 1; // double threshold
        }
        //2.如果舊的閾值是>0說明之前已經初始化過Map，第一次put的時候
        else if (oldThr > 0) // initial capacity was placed in threshold
            //當table沒初始化時，threshold持有初始容量,threshold = tableSizeFor(t);
            newCap = oldThr;
            //3.使用默認初始化後，第一次put的時候
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 新閾值爲0
        if (newThr == 0) {
            float ft = (float) newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
                    (int) ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        // 初始化table-使用新的容量
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        table = newTab;//至此初始化完成

        // 如果舊數組中的數據不爲空，就需要完成數組的拷貝
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K, V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果該數組位置是一個元素的鏈表，直接遷移就好
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                        // 若節點是　TreeNode 節點，要進行 紅黑樹的 rehash　操作
                    else if (e instanceof TreeNode)
                        ((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
                        // 若是鏈表，進行鏈表的 rehash　操作根據(e.hash & oldCap)是否爲0進行分割（代碼後有圖解，可以回過頭再來看），分成兩個不同的鏈表，完成rehash
                        // 需要將此鏈表拆成兩個鏈表，放到新的數組中，並且保留原來的先後順序
                        // loHead、loTail 對應一條鏈表，hiHead、hiTail 對應另一條鏈表
                    else { // preserve order
                        Node<K, V> loHead = null, loTail = null;
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        do {
                            next = e.next;
                            // 根據算法　e.hash & oldCap 判斷節點位置rehash　後是否發生改變
                            //最高位==0，這是索引不變的鏈表。
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            //最高位==1 （這是索引發生改變的鏈表）
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            // 原bucket位置的尾指針不爲空(即還有node)
                            loTail.next = null;
                            // 第一條鏈表
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            // 第二條鏈表的新的位置是 j + oldCap
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
}

 put() 過程分析

• 根據table判斷是否進行擴容
• 根據hash值找到數組的下標-如果當前位置沒有值，直接初始化Node並放置在這個位置
• 如果hash對應的下標下有值，如果是鏈表的話進行鏈表的尾插法插入數據(Java7中是頭插法)，如果數量達到8個需要將鏈表變成紅黑樹結構
• 如果是紅黑樹，則進行紅黑樹的數據插入
• 最後再次判斷是否需要擴容
• 返回null或者返回被替換位置的舊值

   //實際是調用putVal()方法
   public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

// 第四個參數 onlyIfAbsent 如果是 true，那麼只有在不存在該 key 時纔會進行 put 操作
// 第五個參數 evict在進行方法增強的時候纔會使用到
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 如果數組是null或者是數組長度是0，會觸發擴容操作
    // 第一次 resize 和後續的擴容有些不一樣，因爲這次是數組從 null 初始化到默認的 16 或自定義的初始容量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 找到具體的數組下標，如果此位置沒有值，那麼直接初始化一下 Node 並放置在這個位置就可以了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 數組該位置有數據
    else {
        Node<K,V> e; K k;
        // 首先，判斷該位置的第一個數據和我們要插入的數據，key 是不是"相等"，如果是，取出這個節點
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果該節點是代表紅黑樹的節點，調用紅黑樹的插值方法 
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 到這裏，說明數組該位置上是一個鏈表
            for (int binCount = 0; ; ++binCount) {
                // 插入到鏈表的最後面(Java7 是插入到鏈表的最前面)
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // TREEIFY_THRESHOLD 爲 8，所以，如果新插入的值是鏈表中的第 8 個
                    // 會觸發下面的 treeifyBin，也就是將鏈表轉換爲紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果在該鏈表中找到了"相等"的 key(== 或 equals)
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 此時 break，那麼 e 爲鏈表中[與要插入的新值的 key "相等"]的 node
                    break;
                p = e;
            }
        }
        // e!=null 說明存在舊值的key與要插入的key"相等"
        // 對於我們分析的put操作，下面這個 if 其實就是進行 "值覆蓋"，然後返回舊值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);//空實現
            return oldValue;
        }
    }
    ++modCount;
    // 如果 HashMap 由於新插入這個值導致 size 已經超過了閾值，需要進行擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);//方法是空實現-可自行實現
    return null;
}

get() 過程分析

• 計算 key 的 hash 值，根據 hash 值找到對應數組下標: hash & (length-1)
• 判斷數組該位置處的元素是否剛好就是我們要找的，如果是直接獲取找到的數據，否則繼續向下執行
• 判斷該元素類型是否是 TreeNode，如果是，用紅黑樹的方法取數據，否則，繼續執行
• 遍歷鏈表，直到找到相等(==或equals)的 key

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

 

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 判斷第一個節點是不是就是需要的
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            // 判斷是否是紅黑樹
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);

            // 鏈表遍歷
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

對於其他的操作方法，基本邏輯大致爲：

• 根據key獲取hash值
• 根據hash值定位到數組的角標
• 獲取角標下的數組元素，如果是鏈表，按照鏈表的操作方式進行操作，如果是紅黑樹按照紅黑樹的操作方式進行操作