JDK源碼學習之集合框架HashMap

前言：

先上Java集合框架框圖，以對其整體把握

概述

本文將解析HashMap的工作原理，put()和get()方法的過程是如何實現的，equals()和hashCode()的都有什麼作用，HashMap的大小超過了負載因子(load factor)定義的容量，怎麼辦？即HashMap是如何擴容的？
先看下面程序的基本操作：

Map map = new HashMap<String,Integer>();
        map.put("A",90);
        map.put("B",91);
        map.put("C",92);
        map.put("D",92);
        map.put("數學",90);
        map.put("化學",87);
        Set<Map.Entry> set = map.entrySet();
        for(Map.Entry e: set){
            System.out.println("name:" + e.getKey() + " " +"grade:" + e.getValue());
        }

運行結果：

name:A grade:90
name:B grade:91
name:C grade:92
name:D grade:92
name:數學 grade:90
name:化學 grade:87

下圖即表示上面的數據的存儲結構，這樣先對Hashmap 有一個基本認識。

HashMap源碼分析：

Hashmap的核心成員變量：

//HashMap的哈希桶數組，非常重要的存儲結構，用於存放表示鍵值對數據的Node元素。
transient Node<K,V>[] table;
//HashMap將數據轉換成set的另一種存儲形式，這個變量主要用於迭代功能。
transient Set<Map.Entry<K,V>> entrySet;  
//HashMap中實際存在的Node數量，注意這個數量不等於table的長度，甚至可能大於它，因爲在table的每個節點上是一個鏈表（或RBT）結構，可能不止有一個Node元素存在。
transient int size;　　　　　　　　　　　　　
//HashMap的數據被修改的次數，這個變量用於迭代過程中的Fail-Fast機制，其存在的意義在於保證發生了線程安全問題時，能及時的發現（操作前備份的count和當前modCount不相等）並拋出異常終止操作。
transient int modCount;　　　　　　　　　　 
//HashMap的擴容閾值，在HashMap中存儲的Node鍵值對超過這個數量時，自動擴容容量爲原來的二倍。
int threshold;　　　　　　　　　　　　　　　　
//HashMap的負載因子，可計算出當前table長度下的擴容閾值：threshold = loadFactor * table.length。 
final float loadFactor;　　　　　　　　　　　

在HashMap實現了一個內部類Node

static class Node<K,V> implements Map.Entry<K,V> {
　　final int hash;
　　final K key;
    V value;
    Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}

HashMap 的核心常量:

       //默認的初始容量爲16，必須是2的冪次
       static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
       //最大容量即2的30次方
       static final int MAXIMUM_CAPACITY = 1 << 30;

       //默認加載因子
       static final float DEFAULT_LOAD_FACTOR = 0.75f;

       //當put一個元素時，其鏈表長度達到8時將鏈表轉換爲紅黑樹
       static final int TREEIFY_THRESHOLD = 8;

       //鏈表長度小於6時，解散紅黑樹
       static final int UNTREEIFY_THRESHOLD = 6;

       //默認的最小的擴容量64，爲避免重新擴容衝突，至少爲4 * TREEIFY_THRESHOLD=32，即默認初始容量的2倍
       static final int MIN_TREEIFY_CAPACITY = 64;

1、put()過程解析

//put()函數
public V put(K key, V value) {
        //調用putVal()函數
        //並計算key的哈希值
        return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
        int h;
        //計算key的哈希值，在這裏將hashCode()計算結果的
        //高位與低位做異或運算以後，作爲哈希值
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

這裏通過key.hashCode()計算出key的哈希值，然後將哈希值h右移16位，再與原來的h做異或^運算——這一步是高位運算。這樣才能保證hash值所有位的數值特徵都保存下來而沒有遺漏，從而使映射結果儘可能的鬆散。最後，根據 n-1 做與操作的取模運算（即n的餘數），便得到了table數組的索引。

//這裏onlyIfAbsent表示只有在該key對應原來的value爲null的時候才插入，
     // 也就是說如果value之前存在了，就不會被新put的元素覆蓋。
     //evict參數用於LinkedHashMap中的尾部操作，這裏沒有實際意義。
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; //定義變量tab是將要操作的Node數組引用，
        Node<K,V> p; //p表示tab上的某Node節點，
        int n, i;//n爲tab的長度，i爲tab的下標。　
        //判斷當table爲null或者tab的長度爲0時，
        //即table尚未初始化，此時通過resize()方法得到初始化的table
        //這種情況是可能發生的，HashMap的註釋中提到：
        //The table, initialized on first use, and resized as necessary。　　　　　　　　　　　　　　　　　　
        if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
        //此處通過（n - 1） & hash 計算出的值作爲tab的下標i，
        //並另p表示tab[i]，也就是該鏈表第一個節點的位置。並判斷p是否爲null。
        //當p爲null時，表明tab[i]上沒有任何元素，那麼接下來就new
        //第一個Node節點，調用newNode方法返回新節點賦值給tab[i]。　　　　　　　　　　　　　　　　　　　　　　　　
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
            //下面進入p不爲null的情況，有三種情況：
            //第一種：p爲鏈表節點；
            //第二種：p爲紅黑樹節點；
            //第三種：p是鏈表節點但長度爲臨界長度TREEIFY_THRESHOLD，再插入任何元素就要變成紅黑樹了。　　　　　　　　　　　　　　　　
        else {
            Node<K,V> e;//定義e引用即將插入的Node節點，並且下文可以看出 k = p.key。
            K k;
                //HashMap中判斷key相同的條件是key的hash相同，並且符合equals方法。
                //這裏判斷了p.key是否和插入的key相等，如果相等，則將p的引用賦給e。
                //這一步的判斷其實是屬於一種特殊情況，即HashMap中已經存在了key，
                //於是插入操作就不需要了，只要把原來的value覆蓋就可以了。
                //這裏爲什麼要把p賦值給e，而不是直接覆蓋原值呢？答案很簡單，
                //現如果第一個節點就是就跟要插入的節點相同，賦值給e　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
            if (p.hash == hash &&
               ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
                //現在開始了第一種情況，p是紅黑樹節點，那麼肯定插入後仍然是紅黑樹節點，
                //所以我們直接強制轉型p後調用TreeNode.putTreeVal方法，返回的引用賦給e
                //你可能好奇，這裏怎麼不遍歷tree看看有沒有key相同的節點呢？其實，
                // putTreeVal內部進行了遍歷，存在相同hash時返回被覆蓋的TreeNode，否則返回null。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                //接下里就是p爲鏈表節點的情形，也就是上述說的另外兩類情況：
                //插入後還是鏈表/插入後轉紅黑樹。另外，上行轉型代碼也說明了TreeNode是Node的一個子類。
            else {
                //我們需要一個計數器來計算當前鏈表的元素個數，並遍歷鏈表，
                //binCount就是這個計數器。
                for (int binCount = 0; ; ++binCount) {
                    //遍歷過程中當發現p.next爲null時，說明鏈表到頭了，
                    //直接在p的後面插入新的鏈表節點，即把新節點的引用賦給p.next，
                    //插入操作就完成了。注意此時e賦給p。
                    if ((e = p.next) == null) {
                        //最後一個參數爲新節點的next，這裏傳入null，
                        // 保證了新節點繼續爲該鏈表的末端。
                        p.next = newNode(hash, key, value, null);
                        ////插入成功後，要判斷是否需要轉換爲紅黑樹，
                        // 因爲插入後鏈表長度加1，而binCount並不包含新節點，
                        // 所以判斷時要將臨界閾值減1。
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //當鏈表長度大於8時，調用treeifyBin方法，將該鏈表轉換爲紅黑樹。　　  
                            treeifyBin(tab, hash);
                        //當然如果不滿足轉換條件，那麼插入數據後結構也無需變動，
                        // 所有插入操作也到此結束了，break退出即可。
                        break; 
                    }
                    //在遍歷鏈表的過程中，我之前提到了，有可能遍歷到與插入的key相同的節點，
                    //此時只要將這個節點引用賦值給e，最後通過e去把新的value覆蓋掉就可以了。
                    //老樣子判斷key的哈希值並且滿足equals()方法
                    if (e.hash == hash && 
                       ((k = e.key) == key || (key != null && key.equals(k))))
                    //找到了相同key的節點，那麼插入操作也不需要了，直接break退出循環進行最後的value覆蓋操作。    
                    break;
                    //前面提到過，e是當前遍歷的節點p的下一個節點，
                    // p = e 就是依次遍歷鏈表的核心語句。每次循環時p都是下一個node節點。
                    p = e;
                }
            }
            //左邊註釋爲jdk自帶註釋，說的很明白了，針對已經存在key的情況做處理。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;//定義oldValue，即原存在的節點e的value值。
                //前面提到，onlyIfAbsent表示存在key相同時不做覆蓋處理，
                //這裏作爲判斷條件，可以看出當onlyIfAbsent爲false或者oldValue爲null時，進行覆蓋操作
                if (!onlyIfAbsent || oldValue == null)。
                e.value = value;//覆蓋操作，將原節點e上的value設置爲插入的新value。
                //這個函數在hashmap中沒有任何操作，是個空函數，他存在主要是爲了
                //linkedHashMap裏面的一些後續處理工作。
                afterNodeAccess(e);
                //這裏很有意思，他返回的是被覆蓋的oldValue。我們在使用put方法時很少用他的返回值
                //，甚至忘了它的存在，這裏我們知道，他返回的是被覆蓋的oldValue。
                return oldValue;
            }
        }
        //收尾工作，值得一提的是，對key相同而覆蓋oldValue的情況，在前面已經return，
        //不會執行這裏，所以那一類情況不算數據結構變化，並不改變modCount值。
        ++modCount;
        //同理，覆蓋oldValue時顯然沒有新元素添加，除此之外都新增了一個元素，
        //這裏++size並與threshold判斷是否達到了擴容標準。
        if (++size > threshold)
        resize(); //當HashMap中存在的node節點大於threshold時，hashmap進行擴容。
        //這裏與前面的afterNodeAccess同理，是用於linkedHashMap的尾部操作，HashMap中並無實際意義。1
        afterNodeInsertion(evict);
        return null;//最終，對於真正進行插入元素的情況，put函數一律返回null。
    }

在putVal()中有resize()函數，也就是HashMap的擴容機制，擴容後大小爲原來的2倍，這也是table容量爲什麼是2的指數次冪的原因。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table; // oldTable:當前的表
        int oldCap = (oldTab == null) ? 0 : oldTab.length;  //如果你是新創建的話 表的大小就是0 否則就是原來的大小
        //第一次是爲0的    代表 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        int oldThr = threshold;     
        int newCap, newThr = 0; //新的容量和新的擴容
        //如果舊的容量大於0
        if (oldCap > 0) {
        //如果舊的容量大於最大的容量
            if (oldCap >= MAXIMUM_CAPACITY) {   
            //那麼擴容大小 = 最大範圍
                threshold = Integer.MAX_VALUE;  
            //直接返回了
                return oldTab;  
            }
        //否則 如果新的大小等於 oldCap * 2 < 最大的容量 ， 並且舊的容量大於默認的初始化大小16
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
     // double threshold  新的擴容 = 舊的擴容 * 2 
                newThr = oldThr << 1;
        }
        else if (oldThr > 0) // initial capacity was placed in threshold 
            newCap = oldThr;    //如果舊的擴容本來就大於0，那麼新的容量就是舊的擴容
        else {               // zero initial threshold signifies using defaults 說明是 threshold爲0的時候的情況
            newCap = DEFAULT_INITIAL_CAPACITY;      //新的容量爲默認容器的容量
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //新的闕值爲 默認的容量 * 負載因子
        }   
        if (newThr == 0) {  //如果新的擴容爲0 
            float ft = (float)newCap * loadFactor;  //計算得到新的闕值
        //新的闕值 =  如果新的容量小於 最大的容量 並且 新的闕只 < 最大的容量 那麼新的闕值 = 計算的 否則 = 最大int
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr; //闕值 = 新的闕值
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//創建一個新的哈希數組桶 大小爲新的容量    
        table = newTab; // 
        if (oldTab != null) {
    //遍歷舊的hash桶
        for (int j = 0; j < oldCap; ++j) {  
                Node<K,V> e;    
                if ((e = oldTab[j]) != null) {//如果舊的hash桶的元素不爲null  e爲舊的hash桶的元素
                    oldTab[j] = null;   //舊的hash桶設置爲null
                    if (e.next == null)     //如果你就是一個元素
                        newTab[e.hash & (newCap - 1)] = e;  //那麼在新的hash桶給你安排一個位置  位置是你的hash值 & 新的桶的容量-1 這相當於 你的hash值 與 你的容量進行取模運算
                    else if (e instanceof TreeNode) //如果你不只一個元素並且是TreeNode
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//分割  將樹中的節點 分割到高位或者地位上去  
                    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;
                            if ((e.hash & oldCap) == 0) {   //看是否需要進行位置變化 新增位的值 不需要變化就放在原來的位置
                                if (loTail == null)
                                    loHead = e; 
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {      //需要變化 就構建高位放置的鏈表
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead; //賦值 （原來位置）
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;//在新鏈表的位置賦值
                        }
                    }
                }
            }
        }
        return newTab;
    }

接着看下一篇：JDK源碼學習之HashMap擴容機制resize()