Java HashMap中在resize()時候的rehash,即再哈希法的理解

 

HashMap的擴容機制---resize()

 

雖然在hashmap的原理里面有這段，但是這個單獨拿出來講rehash或者resize()也是極好的。

什么時候擴容：當向容器添加元素的時候，會判斷當前容器的元素個數，如果大於等於閾值(知道這個閾字怎么念嗎？不念fa值，念yu值四聲)---即當前數組的長度乘以加載因子的值的時候，就要自動擴容啦。

擴容(resize)就是重新計算容量，向HashMap對象里不停的添加元素，而HashMap對象內部的數組無法裝載更多的元素時，對象就需要擴大數組的長度，以便能裝入更多的元素。當然Java里的數組是無法自動擴容的，方法是使用一個新的數組代替已有的容量小的數組，就像我們用一個小桶裝水，如果想裝更多的水，就得換大水桶。

先看一下什么時候，resize();

 

/** 
 * HashMap 添加節點 
 * 
 * @param hash        當前key生成的hashcode 
 * @param key         要添加到 HashMap 的key 
 * @param value       要添加到 HashMap 的value 
 * @param bucketIndex 桶，也就是這個要添加 HashMap 里的這個數據對應到數組的位置下標 
 */  
void addEntry(int hash, K key, V value, int bucketIndex) {  
    //size：The number of key-value mappings contained in this map.  
    //threshold：The next size value at which to resize (capacity * load factor)  
    //數組擴容條件：1.已經存在的key-value mappings的個數大於等於閾值  
    //             2.底層數組的bucketIndex坐標處不等於null  
    if ((size >= threshold) && (null != table[bucketIndex])) {  
        resize(2 * table.length);//擴容之后，數組長度變了  
        hash = (null != key) ? hash(key) : 0;//為什么要再次計算一下hash值呢？  
        bucketIndex = indexFor(hash, table.length);//擴容之后，數組長度變了，在數組的下標跟數組長度有關，得重算。  
    }  
    createEntry(hash, key, value, bucketIndex);  
}  
  
/** 
 * 這地方就是鏈表出現的地方，有2種情況 
 * 1，原來的桶bucketIndex處是沒值的，那么就不會有鏈表出來啦 
 * 2，原來這地方有值，那么根據Entry的構造函數，把新傳進來的key-value mapping放在數組上，原來的就掛在這個新來的next屬性上了 
 */  
void createEntry(int hash, K key, V value, int bucketIndex) {  
    HashMap.Entry<K, V> e = table[bucketIndex];  
    table[bucketIndex] = new HashMap.Entry<>(hash, key, value, e);  
    size++;  
}

 

 

我們分析下resize的源碼，鑒於JDK1.8融入了紅黑樹，較復雜，為了便於理解我們仍然使用JDK1.7的代碼，好理解一些，本質上區別不大，具體區別后文再說。

 

    void resize(int newCapacity) {   //傳入新的容量
        Entry[] oldTable = table;    //引用擴容前的Entry數組
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {  //擴容前的數組大小如果已經達到最大(2^30)了
            threshold = Integer.MAX_VALUE; //修改閾值為int的最大值(2^31-1)，這樣以后就不會擴容了
            return;
        }
 
        Entry[] newTable = new Entry[newCapacity];  //初始化一個新的Entry數組
        transfer(newTable);                         //！！將數據轉移到新的Entry數組里
        table = newTable;                           //HashMap的table屬性引用新的Entry數組
        threshold = (int) (newCapacity * loadFactor);//修改閾值
    }

 

這里就是使用一個容量更大的數組來代替已有的容量小的數組，transfer()方法將原有Entry數組的元素拷貝到新的Entry數組里。

 

    void transfer(Entry[] newTable) {
        Entry[] src = table;                   //src引用了舊的Entry數組
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) { //遍歷舊的Entry數組
            Entry<K, V> e = src[j];             //取得舊Entry數組的每個元素
            if (e != null) {
                src[j] = null;//釋放舊Entry數組的對象引用（for循環后，舊的Entry數組不再引用任何對象）
                do {
                    Entry<K, V> next = e.next;
                    int i = indexFor(e.hash, newCapacity); //！！重新計算每個元素在數組中的位置
                    e.next = newTable[i]; //標記[1]
                    newTable[i] = e;      //將元素放在數組上
                    e = next;             //訪問下一個Entry鏈上的元素
                } while (e != null);
            }
        }
    }

 

 

 

    static int indexFor(int h, int length) {
        return h & (length - 1);
    }

 

文章中間部分:四、存儲實現；詳細解釋了為什么indexFor方法中要h & (length-1)

 

newTable[i]的引用賦給了e.next，也就是使用了單鏈表的頭插入方式，同一位置上新元素總會被放在鏈表的頭部位置；這樣先放在一個索引上的元素終會被放到Entry鏈的尾部(如果發生了hash沖突的話），這一點和Jdk1.8有區別，下文詳解。在舊數組中同一條Entry鏈上的元素，通過重新計算索引位置后，有可能被放到了新數組的不同位置上。

從上面的for循環內部開始說起吧:詳細解釋下，這個轉存的過程。和怎么個頭插入法.
Entry<K, V> e = src[j];
這句話，就把原來數組上的那個鏈表的引用就給接手了，所以下面src[j] = null;可以放心大膽的置空，釋放空間。告訴gc這個地方可以回收啦。
繼續到do while 循環里面，
Entry<K, V> next = e.next;
int i = indexFor(e.hash, newCapacity);計算出元素在新數組中的位置
下面就是單鏈表的頭插入方式轉存元素啦

關於這個 單鏈表的頭插入方式 的理解，我多說兩句。
這地方我再看的時候，就有點蒙了，他到底怎么在插到新的數組里面的？
要是在插入新數組的時候，也出現了一個數組下標的位置處，出現了多個節點的話，那又是怎么插入的呢？
1，假設現在剛剛插入到新數組上，因為是對象數組，數組都是要默認有初始值的，那么這個數組的初始值都是null。不信的可以新建個Javabean數組測試下。
那么e.next = newTable[i],也就是e.next = null啦。然后再newTable[i] = e;也就是 說這個時候，這個數組的這個下標位置的值設置成這個e啦。
2，假設這個時候，繼續上面的循環，又取第二個數據e2的時候，恰好他的下標和剛剛上面的那個下標相同啦，那么這個時候，是又要有鏈表產生啦、
e.next = newTable[i];，假設上面第一次存的叫e1吧，那么現在e.next = newTable[i];也就是e.next = e1；
然后再，newTable[i] = e;，把這個后來的賦值在數組下標為i的位置，當然他們兩個的位置是相同的啦。然后注意現在的e，我們叫e2吧。e2.next指向的是剛剛的e1，e1的next是null。
這就解釋啦：先放在一個索引上的元素終會被放到Entry鏈的尾部。這句話。

關於什么時候resize（）的說明：
看1.7的源碼上說的條件是：
if ((size >= threshold) && (null != table[bucketIndex])) {。。。}
其中
size表示當前hashmap里面已經包含的元素的個數。
threshold：threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
一般是容量值X加載因子。
而1.8的是：
if (++size > threshold){}
其中
size：The number of key-value mappings contained in this map.和上面的是一樣的
threshold：newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
也是一樣的，
最后總結一下：就是這個map里面包含的元素，也就是size的值，大於等於這個閾值的時候，才會resize（）；
具體到實際情況就是：假設現在閾值是4；在添加下一個假設是第5個元素的時候，這個時候的size還是原來的，還沒加1，size=4，那么閾值也是4的時候，
當執行put方法，添加第5個的時候，這個時候，4 >= 4。元素個數等於閾值。就要resize（）啦。添加第4的時候，還是3 >= 4不成立，不需要resize（）。
經過這番解釋，可以發現下面的這個例子，不應該是在添加第二個的時候resize（），而是在添加第三個的時候，才resize（）的。
這個也是我后來再細看的時候，發現的。當然，這個咱可以先忽略，重點看如何resize（），以及如何將舊數據移動到新數組的

下面舉個例子說明下擴容過程。

這句話是重點----hash(){return key % table.length;}方法,就是翻譯下面的一行解釋：

假設了我們的hash算法就是簡單的用key mod 一下表的大小（也就是數組的長度）。

其中的哈希桶數組table的size=2， 所以key = 3、7、5，put順序依次為 5、7、3。在mod 2以后都沖突在table[1]這里了。這里假設負載因子 loadFactor=1，即當鍵值對的實際大小size 大於 table的實際大小時進行擴容。接下來的三個步驟是哈希桶數組 resize成4，然后所有的Node重新rehash的過程。

 

下面我們講解下JDK1.8做了哪些優化。經過觀測可以發現，我們使用的是2次冪的擴展(指長度擴為原來2倍)，所以，

經過rehash之后，元素的位置要么是在原位置，要么是在原位置再移動2次冪的位置。對應的就是下方的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() {

 

看下圖可以明白這句話的意思，n為table的長度，圖（a）表示擴容前的key1和key2兩種key確定索引位置的示例，圖（b）表示擴容后key1和key2兩種key確定索引位置的示例，其中hash1是key1對應的哈希值(也就是根據key1算出來的hashcode值)與高位與運算的結果。

元素在重新計算hash之后，因為n變為2倍，那么n-1的mask范圍在高位多1bit(紅色)，因此新的index就會發生這樣的變化：

因此，我們在擴充HashMap的時候，不需要像JDK1.7的實現那樣重新計算hash，只需要看看原來的hash值新增的那個bit是1還是0就好了，是0的話索引沒變，是1的話索引變成“原索引+oldCap”，可以看看下圖為16擴充為32的resize示意圖：

我是 沒看懂他連個圖是怎么前后對應的，誰看懂了，交流哈賽。

當時上面這個圖，沒看懂，是因為，他就沒說每個節點的hashcode是啥，他怎么確定是保留在原來的位置，還是說在原來位置的基礎上再加個原來數組的長度呢。所以，上面那個圖僅僅具有丁點兒參考價值。

這個設計確實非常的巧妙，既省去了重新計算hash值的時間，而且同時，由於新增的1bit是0還是1可以認為是隨機的，因此resize的過程，均勻的把之前的沖突的節點分散到新的bucket了。這一塊就是JDK1.8新增的優化點。有一點注意區別，JDK1.7中rehash的時候，舊鏈表遷移新鏈表的時候，如果在新表的數組索引位置相同，則鏈表元素會倒置，但是從上圖可以看出，JDK1.8不會倒置。有興趣的同學可以研究下JDK1.8的resize源碼，寫的很贊，如下:

1.  
   1 final Node<K,V>[] resize() {
2.  
   2 Node<K,V>[] oldTab = table;
3.  
   3 int oldCap = (oldTab == null) ? 0 : oldTab.length;
4.  
   4 int oldThr = threshold;
5.  
   5 int newCap, newThr = 0;
6.  
   6 if (oldCap > 0) {
7.  
   7 // 超過最大值就不再擴充了，就只好隨你碰撞去吧
8.  
   8 if (oldCap >= MAXIMUM_CAPACITY) {
9.  
   9 threshold = Integer.MAX_VALUE;
10.  
    10 return oldTab;
11.  
    11 }
12.  
    12 // 沒超過最大值，就擴充為原來的2倍
13.  
    13 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
14.  
    14 oldCap >= DEFAULT_INITIAL_CAPACITY)
15.  
    15 newThr = oldThr << 1; // double threshold
16.  
    16 }
17.  
    17 else if (oldThr > 0) // initial capacity was placed in threshold
18.  
    18 newCap = oldThr;
19.  
    19 else { // zero initial threshold signifies using defaults
20.  
    20 newCap = DEFAULT_INITIAL_CAPACITY;
21.  
    21 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
22.  
    22 }
23.  
    23 // 計算新的resize上限
24.  
    24 if (newThr == 0) {
25.  
    25
26.  
    26 float ft = (float)newCap * loadFactor;
27.  
    27 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
28.  
    28 (int)ft : Integer.MAX_VALUE);
29.  
    29 }
30.  
    30 threshold = newThr;
31.  
    31 @SuppressWarnings({"rawtypes"，"unchecked"})
32.  
    32 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
33.  
    33 table = newTab;
34.  
    34 if (oldTab != null) {
35.  
    35 // 把每個bucket都移動到新的buckets中
36.  
    36 for (int j = 0; j < oldCap; ++j) {
37.  
    37 Node<K,V> e;
38.  
    38 if ((e = oldTab[j]) != null) {
39.  
    39 oldTab[j] = null;
40.  
    40 if (e.next == null)
41.  
    41 newTab[e.hash & (newCap - 1)] = e;
42.  
    42 else if (e instanceof TreeNode)
43.  
    43 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
44.  
    44 else { // 鏈表優化重hash的代碼塊
45.  
    45 Node<K,V> loHead = null, loTail = null;
46.  
    46 Node<K,V> hiHead = null, hiTail = null;
47.  
    47 Node<K,V> next;
48.  
    48 do {
49.  
    49 next = e.next;
50.  
    50 // 原索引
51.  
    51 if ((e.hash & oldCap) == 0) {
52.  
    52 if (loTail == null)
53.  
    53 loHead = e;
54.  
    54 else
55.  
    55 loTail.next = e;
56.  
    56 loTail = e;
57.  
    57 }
58.  
    58 // 原索引+oldCap
59.  
    59 else {
60.  
    60 if (hiTail == null)
61.  
    61 hiHead = e;
62.  
    62 else
63.  
    63 hiTail.next = e;
64.  
    64 hiTail = e;
65.  
    65 }
66.  
    66 } while ((e = next) != null);
67.  
    67 // 原索引放到bucket里
68.  
    68 if (loTail != null) {
69.  
    69 loTail.next = null;
70.  
    70 newTab[j] = loHead;
71.  
    71 }
72.  
    72 // 原索引+oldCap放到bucket里
73.  
    73 if (hiTail != null) {
74.  
    74 hiTail.next = null;
75.  
    75 newTab[j + oldCap] = hiHead;
76.  
    76 }
77.  
    77 }
78.  
    78 }
79.  
    79 }
80.  
    80 }
81.  
    81 return newTab;
82.  
    82 }