cti 那不 累加 map集合 版本 結點 精神 plain objects

HashMap 的數據結構
? hashMap 初始的數據結構如下圖所示OA現金盤平臺出租QQ2952777280【話仙源碼論壇】hxforum.com【木瓜源碼論壇】papayabbs.com，內部維護一個數組，然後數組上維護一個單鏈表，有個形象的比喻就是想掛鉤一樣，數組腳標一樣的，一個一個的節點往下掛。

hashMap初始數據結構圖

? 我們可以看源碼來驗證下，HashMap 的數據結構是不是真的是像上面所說是數組加鏈表的形式：

//此處略過其他代碼，只截取出了hashMap的數組結構相關的數組與鏈表
public class HashMap<K,V> extends AbstractMap<K,V>

implements Map<K,V>, Cloneable, Serializable {

private static final long serialVersionUID = 362498820763181265L;

/* ---------------- Fields -------------- */

/**
 * The table, initialized on first use, and resized as
 * necessary. When allocated, length is always a power of two.
 * (We also tolerate length zero in some operations to allow
 * bootstrapping mechanics that are currently not needed.)
 */
 //這個是hashMap內部維護的數組
transient Node<K,V>[] table;

/**
 * Basic hash bin node, used for most entries.  (See below for
 * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
 */
 //這個是數組元素的節點類，next的屬性表示下一個節點，即數組的節點元素維護的下一個節點的元素，那不是就是鏈表嗎
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; //數組的腳標值，下面會詳細描述這個內容
    final K key; //map的key
    V value; //map的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 的數據結構正如上文所述，是一個數組加鏈表的形式存儲數組，那麽數組的角標是怎麽計算的呢？如果是你來設計，你會怎麽去設計這個角標的計算方式呢？

? 在沒看源碼之前，我做了一個猜想，就是數組的角標我猜想是按照下面的計算方式計算的：

既然是 HashMap，那肯定有個 hashCode

然後通過 key 值的 hashCode 與數組的長度取模

取模之後，數值一樣的，就往數組的節點上面往下掛

上面是我的猜想，但是 HashMap 的數組角標的實現真的是這樣嗎？我們進入下一節去探究

hash 值的計算
? 既然要看腳標值的計算，那我們肯定要看 HashMap 的 put 方法，因為在 put 方法裏面肯定要計算出腳標的值，然後才能把數據存放到數組裏面去嘛，所以我們直接看 put 的源碼：

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 *         (A <tt>null</tt> return can also indicate that the map
 *         previously associated <tt>null</tt> with <tt>key</tt>.)
 */
//此處是HashMap的put方法的源碼，這個put方法又調了另一個putVal的方法，我們看一下putVal的方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don‘t change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> 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 {

? 這裏我們關註 tab[i] = newNode(hash, key, value, null);這句代碼，前面我們看到了tab就是數組，那說明這句代碼就是給節點賦值，那麽i就是數組的角標那這個i是怎麽計算的呢？

? 看他上面的一句判斷(p = tab[i = (n - 1) & hash]即這個i是通過(n - 1) & hash計算出來的，n = tab.length這個n是數組的長度，就是說數組的角標是通過數組的長度-1與上這個hash，這個跟我們之前猜想的然後通過hashCode與數組的長度取模就不一致了，那這裏我們先保留著這個問題，先看一下hash的計算，從上面代碼中，可以知道，hash值是通過調用hash(key)方法調用得到。

? 這裏我將計算 hash的方法，單獨抽離出來外面寫，如下：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

? key 就是 map 調用 put 方法，put 進來的 key 值，看上面這個方法，前面判空之後返回0的大家一眼就看明白了，主要關註後面的內容，(h = key.hashCode()) ^ (h >>> 16)這句代碼前半部分很明白，就是取key的hashCode值賦給h，（^這個符號表示異或，>>>表示無符號右移），然後與h右移16位後的值進行異或操作。

? 為什麽要這樣計算去計算 hash 呢？這樣計算 hash 又最終與數組的腳標有什麽聯系呢？

? 下面我來畫張圖，來理順這一塊的計算，看下圖：

hashCode異或運算計算hash

? 這樣做可以實現 hashCode 的值，高低位更加均勻地混到一起，結合上面數組腳標(n - 1) & hash的運算，由於 HashMap 數組的大小總是 2^n，即 （2^n-1） 得到的值轉化為二進制，如： 00001111、00011111 （舍棄前面高位）等，與 hash 的值進行與運算，這樣又保證每一個腳標i值都能在數組的長度內。這裏可能有點難理解，舉個例子來說明一下。

? 就是 hashMap 的數組初始大小是 16，那 length-1 的值就為 15，15 的二進制值是.... 0000 1111，此時上面hash 值 363766277 的二進制位 0001 0101 1010 1110 1010 0010 0000 0101，這兩個數進行與運算時，由於 15 的前面高位都為 0，所以進行與運算的值最終都不可能大於15，像這個例子，最終的值為 0101 為 9，這樣就保證了每一個腳標i值都能在數組的長度內。

? 那麽這裏就有一個疑問了，為什麽不直接采用與數組長度取模的方式，直接取得腳標值，而是先去異或，再與運算去計算腳標值？

? 主要有兩個原因：

? 1.用位運算，效率更高

? 2. hashCode 的高低位異或運算，讓高低位更加均勻的混合到一起，可以使得在 put 元素時，可以減少哈希碰撞

? 減少哈希碰撞才是最主要的原因。那什麽是哈希碰撞呢？

? 我們知道 HashMap 的數組結構不是數組加鏈表嗎？那數組跟鏈表有什麽特點？我們都知道數組是查詢快、增刪慢，鏈表是查詢慢、增刪快。

? 這也很容易理解，鏈表嘛，只記錄著下一個節點的值，又沒有腳標，如果你這個鏈表很長（雖然在這裏最長不會超過8，後面會講到），你查找的一個元素剛好在最後一個，那不是在定位到數組腳標以後找到鏈表的第一個節點，然後往下一直遍歷查找到最後一個才找到我們要的元素，這樣效率不就很慢了嗎，所以如果我們直接對 hashCode 跟數組的長度進行取模，計算出的 hash 值可能會碰撞高，就會使得數組單個節點的鏈表很長很長，而這樣子 HashMap 的查詢效率就很差，而 hashCode 的高低位異或運算，可以讓高低位更加均勻的混合到一起，減少哈希碰撞，從而提高 HashMap 的查詢效率。

? 一句話總結，失敗的 hashCode 算法會導致 HashMap 的性能由數組下降為鏈表，所以想要避免發生碰撞，就要提高 hashCode 結果的均勻性。

數組的擴容
數組的初始化長度
? 在上一節的時候，我們講到了 HashMap 的長度總是 2^n 這句話，我們怎麽知道呢，我們可以從源碼中找到這一設定，那麽我們首先先看一下，HashMap 數組初始的默認大小是多少呢，源碼中有這一句代碼

/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

? 但是，我們不能光看這個常量值就說HashMap內數組的默認常量值就是 16 啊，我們要繼續找到初始化的方法代碼，看他是不是初始值為 16

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * @return the table
 */
//上面的英文中說到，初始化或者翻倍數組的大小
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        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
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY; //當oldTab即為table數組的長度，當oldTab長度為0時，將DEFAULT_INITIAL_CAPACITY賦值給newCap，newCap即為數組的新長度
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }

? 我們可以查詢下 resize()方法的調用者，發現putVal()方法裏調用了這個方法

putVal方法調用resize()

? 截圖中的代碼已經很清楚了，就是當 table 數組的長度為 null 或長度為 0 時，調用初始化resize()方法，然後在resize()方法中也做了判斷，當table數組的長度為 0 時，將新數組的長度賦值為DEFAULT_INITIAL_CAPACITY，

? 所以 HashMap 中數組的初始化長度就是 DEFAULT_INITIAL_CAPACITY，等於1 << 4，等於 16

數組擴容的閾值
? 上一節我們知道數組的初始長度是 16，然而 16 的長度顯然不能滿足我們普通應用的開發，所以這裏就涉及到了數組的擴容。那要什麽時候擴容，怎麽擴呢？

? 我們知道，鏈表的查詢效率肯定比數組的查詢效率低，所以要提高 HashMap 的查詢效率，我們肯定要數據盡可能多的往數組上存數據，而不是延長鏈表的長度。那是不是存滿之後再做擴容呢？比方說數組初始化 16，等到存滿 16 的時候或者第 17 個進來的時候，開始擴容呢？

? 我們可以先分析一下，然後再來看源碼。當數組的元素都放滿了，然後這時候來擴容，擴容之後，數組元素的腳標值就得重新計算，即 rehash ，比如原來是計算hash用的數組長度 16，擴容之後數組長度變成了 32，這時候(n - 1) & hash計算腳標的值就不正確了，那你數組都存滿了，那不是數組的每個元素都得重新計算腳標i值，所以這種做法是不是不合理？

hashMap初始數據結構圖

? 所以這裏就有一個數組擴容的閾值，就是說，當數組的長度達到某個值或某個條件時，數組就開始擴容，而這裏的某個值或某個條件就是我們所說的數組擴容的閾值。

? 那麽這個閾值具體是多少呢？下面我們來探究源碼，既然要找到擴容的閾值，那我們不外乎要從兩個方法入手去找，一個就是put()操作的時候，一個就是擴容resize()的時候。因為我已經找過了，我就直接去put()方法裏面找了，resize()方法後面會細講，這裏就講put()方法。

//這裏put方法只調用了putVal方法，那我們就直接看putVal方法
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<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length; //這一步之前分析過了，就是判斷數組為null或長度為0時，對數組進行擴容
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null); //這一步其實也很清楚了，就是根據hash值計算出數組的腳標，然後判斷數組的該腳標的元素是否為空，為空的話就把put進來的數據封裝成節點賦值進數組
    else {
        //根據上面的兩個判斷，那麽走到這裏的代碼就是說，數組不為空，而且put進來的key計算所得的腳標節點也不為空，走這一塊邏輯（實際上這塊邏輯也跟擴容的閾值無關，只是單純的判斷然後加節點的操作，但是我還是解釋下這裏的代碼）
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;//這裏的意思是說，如果hash值相同，key值也相同，那麽就說明此時put操作的元素在數組從存在，這覆蓋該節點
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); //這裏是判斷節點類型是否是樹類型，為什麽會是樹類型呢？不是說是HashMap是數組加鏈表嗎？後面的章節會詳細講到，這裏暫且跳過
        else {
            //代碼走到這裏，就說明此時put進來的元素，對應的數組腳標是個鏈表
            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;
                }
                //這裏判斷hash值與key值是否都相同，如果是即說明map中存在該key-value，此時跳出循環
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //此邏輯是判斷hash值與key值是否都相同跳出循環後，將新值覆蓋舊值，然後將舊值返回出去
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;//hashMap內部維護的一個修改的次數，有興趣了解的話可以看源碼裏面對這個屬性的翻譯
    if (++size > threshold)
        resize();//擴容，在此之前的代碼，都是判斷之後進行添加覆蓋節點的操作，此處是插入新節點之後判斷是否擴容，所以這裏的條件就是我們找了這麽久的擴容的閾值！！！
    afterNodeInsertion(evict);
    return null;
}

? 走讀完上面的代碼，我們可以得知 if (++size > threshold)，如下代碼可知 size實際上就是HashMap集合的鍵值對數，即長度，所以就是說，當 size的大小超過 threshold時，開始進行擴容，也即 threshold就是進行擴容的閾值。那麽這個閾值的大小是多少呢？

/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

/**
 * Returns the number of key-value mappings in this map.
 *
 * @return the number of key-value mappings in this map
 */
public int size() {
    return size;
}

? 繼續走讀源碼，找到 resize()方法處，

resize方法初始化數組長度與閾值

/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

? 當 HashMap 數組為 null 或長度為 0 時，初始化threshold的值，DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY，DEFAULT_INITIAL_CAPACITY為數組的初始長度，DEFAULT_LOAD_FACTOR是閾值的計算因子，他的值是 0.75f，意思就是當 HashMap 的 size 超過數組長度的75%的時候，就進行擴容。

? 我們可以繼續走讀源碼來驗證是否數組長度超過 75% 就進行擴容，還是上面那張圖的源碼，我把其中一段給抽離出來，如下：

    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //此處的意思是說，當數組的長度是大於0的時候，而且數組擴容一倍之後，小於默認配置的最大值時，並且大於初始化數組的長度，則執行if下面的代碼，那就是說，擴容之後如果沒超過最大值，就走這個邏輯
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //而這個邏輯的代碼意思，就是閾值threshold增大一倍（左移一位）
            newThr = oldThr << 1; // double threshold
    }

? 那麽，我們就知道了，當數組擴容時，threshold的值也會增大一倍，那麽下一次擴容時，也是HashMap的 size 超過數組長度的 75% 的時候，就進行擴容。

擴容
? HashMap 內數組的擴容是將數組的長度左移一位，在二進制運算中，左移一位實際上就是將數值擴大一倍。而且我們也知道，擴容的源碼就是resize()這個方法，所以這一章節就來重點解讀resize()方法的源碼

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * @return the table
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table; //oldTab就是擴容前數組對象
    int oldCap = (oldTab == null) ? 0 : oldTab.length; //oldCap就是擴容前數組的長度
    int oldThr = threshold; //oldThr就是擴容前的閾值
    int newCap, newThr = 0; //聲明newCap-擴容後的數組長度，newThr-擴容後的閾值
    if (oldCap > 0) {
        //這一部分邏輯其實上一節已經講過了，在這裏我就大致說一下，就是如果這是擴容前數組長度已經達到了默認配置的最大值時，那麽就不擴容了，直接返回原數組，否則，數組擴容一倍，閾值也增大一倍
        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
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr; //這個判斷不是正常創建Map集合走的邏輯，這裏可以跳過這句代碼
    else {               // zero initial threshold signifies using defaults
        //這一步的代碼前面也解釋過了，就是當數組長度為0，初始化數組長度與擴容的閾值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    //將新的擴容後的閾值賦值給threshold
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        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; //根據hash值與新數組的長度進行與操作，獲取新數組的腳標值，將節點存儲到新數組
                else if (e instanceof TreeNode) //如果節點是樹節點，走這個邏輯，後面講鏈表的紅黑樹的時候會做解釋，這裏先跳過
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { //所以這一部分的邏輯，就是如果節點是鏈表，走這裏
                    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) {
                            //這個判斷是理解這整個鏈表遍歷的關鍵，這裏也涉及到了前面講到的2^n-1對應二進制是0111xxxx的內容，我們知道數組的長度總是2^n，所以oldCap的值實際上就是1000xxxx，然後hash & oldCap的操作，就是判斷oldCap高位的1與對應hash那一位的值是否是1，如果是0走這個邏輯，如果是1走下面的else代碼
                            //這裏，前面聲明的4個變量loHead, loTail, hiHead, hiTail中，lo的指的是低位，hi的指的是高位，走完這個do裏面的邏輯，就是將oldCap高位的1與對應hash那一位的值是0的存到loTail這個鏈表中，高位是1的存到hiTail這個鏈表中！！！！
                            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存放到新數組的原腳標處
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        //將上面遍歷之後高位的hiTail存放到新數組的擴容後的腳標處
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

? 在上面的源碼解讀中，我們可能會留有一個問題，就是為什麽擴容後，對數組中的鏈表還要做 (e.hash & oldCap) == 0的判斷？

? 實際上這部分邏輯是為了提高HashMap的查詢性能，因為數組擴容後，節點要重新散列，那麽節點上面的鏈表當然也最好要做到均勻的分布，減少單個數組節點上的鏈表長度，變相的提高了查詢性能。所以，源碼的邏輯是在擴容後將低位的 loTail 存放到新數組的原腳標處，高位的 hiTail 存放到新數組的擴容後的腳標處（jdk1.8新設計）

jdk1.8 hashMap擴容例圖

? 註：有同學可能會糾結於，為什麽代碼中高位的鏈表是直接 j + oldCap的腳標，不需要重新計算hash與上新數組長度計算嗎？其實這是一個簡單的數學問題而已，你自己舉個例子計算一下就可以明白，結果是一樣的

鏈表的“擴容”
? 前面的章節已經對 HashMap 數組的擴容及其重新散列的內容講完了，這一章節的內容來講一講鏈表的"擴容"。根據前面的內容，我們了解到，如果鏈表的長度越來越長，HashMap 的查詢效率也會隨之降低。所以單純的對鏈表長度的增加，顯然是不可取的。

? 所以在 HashMap 中，對於鏈表實際上並沒有擴容操作。在本文開頭列出的 Node 節點的源碼中也可以看到，內部並沒有維護一個size或者length的屬性，也沒有一個去獲取 length 或 size 相關的方法，所以本章節主要闡述的內容，是鏈表結構向樹狀結構的轉化。

單鏈表-->紅黑樹
? 在前面“數組擴容的閾值”章節的時候，我曾解讀過 putVal 方法的代碼，在解讀過程中，我跳過了兩次代碼邏輯，在這一章節我就來詳細的解讀這兩處邏輯

putVal方法未解讀的兩處邏輯

? 我們先看 for 循環遍歷處的代碼，此處的遍歷的內容是 HashMap 是 put 操作節點是為鏈表時的邏輯：首先這裏先判斷鏈表的next節點是否為空，為空則將 put 操作的 key-value 封裝為 node 對象，賦值給next節點，然後下一步的判斷if (binCount >= TREEIFY_THRESHOLD - 1)是這裏的關鍵，TREEIFY_THRESHOLD 這個是什麽呢？THRESHOLD 這個單詞是不是看著有點眼熟，在前面將數組擴容的閾值的時候，是不是用的這個單詞，那在這裏的TREEIFY_THRESHOLD 會不會就是鏈表結構轉樹狀結構的閾值呢？

? 通過上面這段代碼的上下文，我們知道 binCount就是鏈表的長度（註意：這裏是從 0 開始的），而TREEIFY_THRESHOLD 看下面的源碼，默認值是 8，意思就是說當鏈表的長度，大於等於 8 時，就執行treeifyBin(tab, hash);

/**
 * The bin count threshold for using a tree rather than list for a
 * bin.  Bins are converted to trees when adding an element to a
 * bin with at least this many nodes. The value must be greater
 * than 2 and should be at least 8 to mesh with assumptions in
 * tree removal about conversion back to plain bins upon
 * shrinkage.
 */
static final int TREEIFY_THRESHOLD = 8;

? treeifyBin(tab, hash);方法的內容是做什麽呢?

/**
 * Replaces all linked nodes in bin at index for given hash unless
 * table is too small, in which case resizes instead.
 */
//翻譯大概的意思就是，在給定hash的節點處替換節點類型，除非是數組的長度太小了，才進行resize操作
//總結就是說，並不是鏈表的長度超過了默認的閾值8時，就一定轉樹狀結構，還要判斷數組的長度是否已經經過了擴容
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //這裏就是上面翻譯說的判斷，MIN_TREEIFY_CAPACITY的值是64，就是說如果你的數組沒有經過擴容操作的情況下，如果鏈表長度已經超過8了，此時不轉樹狀結構，而是進行數組擴容，數組擴容時會重新散列，將鏈表的節點均勻的分布，查詢效率對比轉樹狀結構也要好，不得不佩服設計者的設計。
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        //此處代碼就是找到給定的hash的節點，將此節點的鏈表轉為紅黑樹，下面的代碼主要是數據結構代碼的內容，有興趣的同學可以自己解讀，由於時間原因，我就不解讀這部分轉紅黑樹的代碼了
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

? 在上面的源碼解讀中，我們知道，並不是鏈表的長度超過了默認的閾值 8 時，就一定轉樹狀結構，還要判斷數組的長度是否已經經過了擴容，就是說如果你的數組沒有經過擴容操作的情況下，如果鏈表長度已經超過 8 了，此時不轉樹狀結構，而是進行數組擴容，數組擴容時會重新散列，將鏈表的節點均勻的分布，查詢效率對比轉樹狀結構也要好。

? 那麽在數組擴容後，鏈表長度也超過了 8，此時就進行轉紅黑樹的操作，那紅黑樹又是什麽呢？

hashMap鏈表轉紅黑樹

? 我們知道鏈表的查詢時間復雜度最壞的情況有可能是 O(n) ，當你想要找到節點剛好是在鏈表的最後一個時，你就必須得遍歷完鏈表中所有的節點才能找到你要的值，查找效率太低。而紅黑樹的本質其實是一棵平衡二叉查找樹，平衡二叉查找樹的特點就是左子節點小於等於父節點，右子節點大於等於父節點，所以他的查詢時間復雜度是 O(Log2n) ，比鏈表的 O(n) 效率就要高很多了。

? 本章開頭說到的另一處未解讀的putVal源碼，其實只是判斷是樹狀結構時，將節點按照紅黑樹的規則，put進樹中而已。

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
HashTable 的數據結構
? 在前面解讀的 HashMap 中，已經將HashMap的數據結構，還有put操作、擴容做了詳細的解讀，而其實 HashTable，只是在 HashMap 的基礎上，給各個操作都加上了 synchronized 關鍵字而已，這就是我們常說的 HashTable 是線程安全的，而 HashMap 是線程不安全的，如下代碼。

public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {

private transient Entry<?,?>[] table; //數組
private int threshold; //數組擴容閾值
private float loadFactor;

//鏈表實體類
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;

//put方法
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}

//remove方法
public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

//get方法
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}
? 內部也是維護了一個數組與鏈表，然後在 put、get 等方法上都加上 synchronized 關鍵字，那這樣就能確保 HashTable 在任何場景都是線程安全的嗎？

HashTable 是否在任何場景都是線程安全的？
? 這裏有幾個場景：

（1）若 key 不存在，則添加元素

（2）若 key 存在，則刪除元素

我在這裏畫張圖來描述下多線程環境下的這兩個場景

hashtable在復合操作下的線程安全問題

存在這樣問題的原因是復合操作的場景下，HashTable不是線程安全的，因為 HashTable 只是保證單個方法操作是原子性的，但在不保證原子性的復合操作下，HashTable 也存在線程安全問題。

ConCurrentHashMap 的數據結構
? 我們知道 HashTable 的性能比 HashMap 的差很多，因為 HashTable 在每個操作方法上面都加了 synchronized 關鍵字，而且在復合場景下還存在線程安全問題，所以 HashTable 算是舊版本遺留下來的問題了，現在的實際開發中一般也不會去使用到 HashTable，但是在 jdk1.5 以後新增了 java.util.concurrent 包，在這個包下提供了很多線程安全又高性能的集合，其中就包含了本章的主角 ConCurrentHashMap

jdk1.7 分段鎖
? 在 jdk1.5 以後到 jdk1.7 ，ConCurrentHashMap 在解決多線程場景下的線程安全問題，采用的是分段鎖的技術。

? 我們知道 HashTable 之所以性能低下，是因為其在 public 方法的實現上都加上了 synchronized 的關鍵字，即當任意一個 put 或 get 操作，都將整個 map 對象鎖住，只有等待持有鎖的線程操作結束，才有機會獲得鎖進行操作。

? 這裏有一種場景，在 Map 的數組 table 中，線程1對 table[0] 進行 put 操作，而此時有線程2想對 table[1] 進行 put 操作，實際上兩者的 put 操作互不幹涉，而在 HashTable 的實現下，線程2只能等待線程1操作完成之後才能執行。那麽，我們是否可以這樣實現，當線程1對 table[0] 進行 put 操作時，對 table[0] 下的鏈表進行加鎖，而操作 table[1] 時，對 table[1] 的鏈表進行加鎖，各自那各自的鎖，這樣線程1在操作 table[0] 時，線程2也可以操作 table[1]。

ConcurrentHashMap分段鎖結構圖

? 分段鎖采用的就是這種思想，在ConCurrentHashMap中維護著Segment[]的數組，這種實現方式把原本 HashTable 粗粒度的鎖實現，拆分成一段一段的Segment鎖。

//jdk1.7的ConcurrentHashMap的源碼
public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
implements ConcurrentMap<K, V>, Serializable {
/**

• Mask value for indexing into segments. The upper bits of a

• key‘s hash code are used to choose the segment.
  */
  final int segmentMask;

  /**

• Shift value for indexing within segments.
  */
  final int segmentShift;

  /**

• The segments, each of which is a specialized hash table.
  */
  //Segment是繼承了可重入鎖的子類，所以在Segment的操作方法中，包含了tryLock、unLock等方法
  final Segment<K,V>[] segments;

  /**

• Segments are specialized versions of hash tables. This
• subclasses from ReentrantLock opportunistically, just to

• simplify some locking and avoid separate construction.
  */
  static final class Segment<K,V> extends ReentrantLock implements Serializable {

  /**
   * The per-segment table. Elements are accessed via
   * entryAt/setEntryAt providing volatile semantics.
   */
  transient volatile HashEntry<K,V>[] table;

  }
  }
  ? 簡單理解就是，ConcurrentHashMap 維護一個 Segment 數組，Segment 通過繼承 ReentrantLock 來進行加鎖，所以每次需要加鎖的操作鎖住的是一個 Segment，這樣只要保證每個 Segment 是線程安全的，也就實現了全局的線程安全。

ConcurrentHashMap的Segment結構

? 如下，是 ConcurrentHashMap 的各個構造方法，但是實際上只有 public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)該構造方法是真正完成初始化的方法，其他的都是方法重載

public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// Find power-of-two sizes best matching arguments
int sshift = 0;
int ssize = 1;
// 計算並行級別 ssize，因為要保持並行級別是 2 的 n 次方
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
// 我們這裏先不要那麽燒腦，用默認值，concurrencyLevel 為 16，sshift 為 4
// 那麽計算出 segmentShift 為 28，segmentMask 為 15，後面會用到這兩個值
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;

    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;

    // initialCapacity 是設置整個 map 初始的大小，
    // 這裏根據 initialCapacity 計算 Segment 數組中每個位置可以分到的大小
    // 如 initialCapacity 為 64，那麽每個 Segment 或稱之為"槽"可以分到 4 個
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    // 默認 MIN_SEGMENT_TABLE_CAPACITY 是 2，這個值也是有講究的，因為這樣的話，對於具體的槽上，
    // 插入一個元素不至於擴容，插入第二個的時候才會擴容
    int cap = MIN_SEGMENT_TABLE_CAPACITY; 
    while (cap < c)
        cap <<= 1;

    // 創建 Segment 數組，
    // 並創建數組的第一個元素 segment[0]
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    // 往數組寫入 segment[0]
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY),
         DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
    putAll(m);
}

? concurrencyLevel：並行級別、並發數、Segment 數，怎麽翻譯不重要，理解它。默認是 16，也就是說 ConcurrentHashMap 有 16 個 Segments，所以理論上，這個時候，最多可以同時支持 16 個線程並發寫，只要它們的操作分別分布在不同的 Segment 上。這個值可以在初始化的時候設置為其他值，但是一旦初始化以後，它是不可以擴容的。

? 再具體到每個 Segment 內部，其實每個 Segment 很像前面介紹的 HashMap，不過它要保證線程安全，所以處理起來要麻煩些。

? initialCapacity：初始容量，這個值指的是整個 ConcurrentHashMap 的初始容量，實際操作的時候需要平均分給每個 Segment。

? loadFactor：負載因子，之前我們說了，Segment 數組不可以擴容，所以這個負載因子是給每個 Segment 內部使用的。

jdk1.8 的新特性：CAS
? 在 jdk1.8 以下版本的 ConcurrentHashMap 為了保證線程安全又要提供高性能的情況下，采用鎖分段的技術，而在java8中對於 ConcurrentHashMap 的實現又變成了另外一種方式----CAS

? CAS的全稱是compare and swap，直譯過來就是比較與替換。CAS的機制就相當於這種（非阻塞算法），CAS是由CPU硬件實現，所以執行相當快.CAS有三個操作參數：內存地址，期望值，要修改的新值，當期望值和內存當中的值進行比較不相等的時候，表示內存中的值已經被別線程改動過，這時候失敗返回，當相等的時候，將內存中的值改為新的值，並返回成功。

? 這裏也不去細講多線程、鎖、CAS這些內容，後續等有空再整理一篇文檔出來做詳細點的筆記，這裏只當做體會精神，理解思想即可。

? 下面的代碼是摘自網上一篇文章的對 java8 中 ConcurrentHashMap 的源碼分析，也是為了方便自己後續當筆記學習來看。

public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// 得到 hash 值
int hash = spread(key.hashCode());
// 用於記錄相應鏈表的長度
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 如果數組"空"，進行數組初始化
if (tab == null || (n = tab.length) == 0)
// 初始化數組，後面會詳細介紹
tab = initTable();

    // 找該 hash 值對應的數組下標，得到第一個節點 f
    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        // 如果數組該位置為空，
        // 用一次 CAS 操作將這個新值放入其中即可，這個 put 操作差不多就結束了，可以拉到最後面了
        // 如果 CAS 失敗，那就是有並發操作，進到下一個循環就好了
        if (casTabAt(tab, i, null,
                     new Node<K,V>(hash, key, value, null)))
            break;                   // no lock when adding to empty bin
    }
    // hash 居然可以等於 MOVED，這個需要到後面才能看明白，不過從名字上也能猜到，肯定是因為在擴容
    else if ((fh = f.hash) == MOVED)
        // 幫助數據遷移，這個等到看完數據遷移部分的介紹後，再理解這個就很簡單了
        tab = helpTransfer(tab, f);

    else { // 到這裏就是說，f 是該位置的頭結點，而且不為空

        V oldVal = null;
        // 獲取數組該位置的頭結點的監視器鎖
        synchronized (f) {
            if (tabAt(tab, i) == f) {
                if (fh >= 0) { // 頭結點的 hash 值大於 0，說明是鏈表
                    // 用於累加，記錄鏈表的長度
                    binCount = 1;
                    // 遍歷鏈表
                    for (Node<K,V> e = f;; ++binCount) {
                        K ek;
                        // 如果發現了"相等"的 key，判斷是否要進行值覆蓋，然後也就可以 break 了
                        if (e.hash == hash &&
                            ((ek = e.key) == key ||
                             (ek != null && key.equals(ek)))) {
                            oldVal = e.val;
                            if (!onlyIfAbsent)
                                e.val = value;
                            break;
                        }
                        // 到了鏈表的最末端，將這個新值放到鏈表的最後面
                        Node<K,V> pred = e;
                        if ((e = e.next) == null) {
                            pred.next = new Node<K,V>(hash, key,
                                                      value, null);
                            break;
                        }
                    }
                }
                else if (f instanceof TreeBin) { // 紅黑樹
                    Node<K,V> p;
                    binCount = 2;
                    // 調用紅黑樹的插值方法插入新節點
                    if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                   value)) != null) {
                        oldVal = p.val;
                        if (!onlyIfAbsent)
                            p.val = value;
                    }
                }
            }
        }
        // binCount != 0 說明上面在做鏈表操作
        if (binCount != 0) {
            // 判斷是否要將鏈表轉換為紅黑樹，臨界值和 HashMap 一樣，也是 8
            if (binCount >= TREEIFY_THRESHOLD)
                // 這個方法和 HashMap 中稍微有一點點不同，那就是它不是一定會進行紅黑樹轉換，
                // 如果當前數組的長度小於 64，那麽會選擇進行數組擴容，而不是轉換為紅黑樹
                //    具體源碼我們就不看了，擴容部分後面說
                treeifyBin(tab, i);
            if (oldVal != null)
                return oldVal;
            break;
        }
    }
}
// 
addCount(1L, binCount);
return null;

}

HashTable、HashMap與ConCurrentHashMap源碼OA現金盤平臺出租解讀