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

 

 

面試的時候聞到了Hashmap的擴容機制，之前只看到了Hasmap的實現機制，補一下基礎知識，講的非常好

 

原文鏈接：

 

http://www.iteye.com/topic/539465

 

Hashmap是一種非常常用的、應用廣泛的數據類型，最近研究到相關的內容，就正好復習一下。網上關於hashmap的文章很多，但到底是自己學習的總結，就發出來跟大家一起分享，一起討論。 

1、hashmap的數據結構 
要知道hashmap是什么，首先要搞清楚它的數據結構，在java編程語言中，最基本的結構就是兩種，一個是數組，另外一個是模擬指針（引用），所有的數據結構都可以用這兩個基本結構來構造的，hashmap也不例外。Hashmap實際上是一個數組和鏈表的結合體（在數據結構中，一般稱之為“鏈表散列“），請看下圖（橫排表示數組，縱排表示數組元素【實際上是一個鏈表】）。 

 

從圖中我們可以看到一個hashmap就是一個數組結構，當新建一個hashmap的時候，就會初始化一個數組。我們來看看java代碼：

 

 

 

/**
     * The table, resized as necessary. Length MUST Always be a power of two.
     *  FIXME 這里需要注意這句話，至於原因后面會講到
     */
    transient Entry[] table;

 

 

 

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

 

上面的Entry就是數組中的元素，它持有一個指向下一個元素的引用，這就構成了鏈表。 
     當我們往hashmap中put元素的時候，先根據key的hash值得到這個元素在數組中的位置（即下標），然后就可以把這個元素放到對應的位置中了。如果這個元素所在的位子上已經存放有其他元素了，那么在同一個位子上的元素將以鏈表的形式存放，新加入的放在鏈頭，最先加入的放在鏈尾。從hashmap中get元素時，首先計算key的hashcode，找到數組中對應位置的某一元素，然后通過key的equals方法在對應位置的鏈表中找到需要的元素。從這里我們可以想象得到，如果每個位置上的鏈表只有一個元素，那么hashmap的get效率將是最高的，但是理想總是美好的，現實總是有困難需要我們去克服，哈哈~ 

2、hash算法 
我們可以看到在hashmap中要找到某個元素，需要根據key的hash值來求得對應數組中的位置。如何計算這個位置就是hash算法。前面說過hashmap的數據結構是數組和鏈表的結合，所以我們當然希望這個hashmap里面的元素位置盡量的分布均勻些，盡量使得每個位置上的元素數量只有一個，那么當我們用hash算法求得這個位置的時候，馬上就可以知道對應位置的元素就是我們要的，而不用再去遍歷鏈表。 

所以我們首先想到的就是把hashcode對數組長度取模運算，這樣一來，元素的分布相對來說是比較均勻的。但是，“模”運算的消耗還是比較大的，能不能找一種更快速，消耗更小的方式那？java中時這樣做的，

 

 

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

 

首先算得key得hashcode值，然后跟數組的長度-1做一次“與”運算（&）。看上去很簡單，其實比較有玄機。比如數組的長度是2的4次方，那么hashcode就會和2的4次方-1做“與”運算。很多人都有這個疑問，為什么hashmap的數組初始化大小都是2的次方大小時，hashmap的效率最高，我以2的4次方舉例，來解釋一下為什么數組大小為2的冪時hashmap訪問的性能最高。 

         看下圖，左邊兩組是數組長度為16（2的4次方），右邊兩組是數組長度為15。兩組的hashcode均為8和9，但是很明顯，當它們和1110“與”的時候，產生了相同的結果，也就是說它們會定位到數組中的同一個位置上去，這就產生了碰撞，8和9會被放到同一個鏈表上，那么查詢的時候就需要遍歷這個鏈表，得到8或者9，這樣就降低了查詢的效率。同時，我們也可以發現，當數組長度為15的時候，hashcode的值會與14（1110）進行“與”，那么最后一位永遠是0，而0001，0011，0101，1001，1011，0111，1101這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，數組可以使用的位置比數組長度小了很多，這意味着進一步增加了碰撞的幾率，減慢了查詢的效率！ 

 


          所以說，當數組長度為2的n次冪的時候，不同的key算得得index相同的幾率較小，那么數據在數組上分布就比較均勻，也就是說碰撞的幾率小，相對的，查詢的時候就不用遍歷某個位置上的鏈表，這樣查詢效率也就較高了。 
          說到這里，我們再回頭看一下hashmap中默認的數組大小是多少，查看源代碼可以得知是16，為什么是16，而不是15，也不是20呢，看到上面annegu的解釋之后我們就清楚了吧，顯然是因為16是2的整數次冪的原因，在小數據量的情況下16比15和20更能減少key之間的碰撞，而加快查詢的效率。 

所以，在存儲大容量數據的時候，最好預先指定hashmap的size為2的整數次冪次方。就算不指定的話，也會以大於且最接近指定值大小的2次冪來初始化的，代碼如下(HashMap的構造方法中)：

 

// Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

 

總結： 
        本文主要描述了HashMap的結構，和hashmap中hash函數的實現，以及該實現的特性，同時描述了hashmap中resize帶來性能消耗的根本原因，以及將普通的域模型對象作為key的基本要求。尤其是hash函數的實現，可以說是整個HashMap的精髓所在，只有真正理解了這個hash函數，才可以說對HashMap有了一定的理解。

 

3、hashmap的resize 

       當hashmap中的元素越來越多的時候，碰撞的幾率也就越來越高（因為數組的長度是固定的），所以為了提高查詢的效率，就要對hashmap的數組進行擴容，數組擴容這個操作也會出現在ArrayList中，所以這是一個通用的操作，很多人對它的性能表示過懷疑，不過想想我們的“均攤”原理，就釋然了，而在hashmap數組擴容之后，最消耗性能的點就出現了：原數組中的數據必須重新計算其在新數組中的位置，並放進去，這就是resize。 

         那么hashmap什么時候進行擴容呢？當hashmap中的元素個數超過數組大小*loadFactor時，就會進行數組擴容，loadFactor的默認值為0.75，也就是說，默認情況下，數組大小為16，那么當hashmap中元素個數超過16*0.75=12的時候，就把數組的大小擴展為2*16=32，即擴大一倍，然后重新計算每個元素在數組中的位置，而這是一個非常消耗性能的操作，所以如果我們已經預知hashmap中元素的個數，那么預設元素的個數能夠有效的提高hashmap的性能。比如說，我們有1000個元素new HashMap(1000), 但是理論上來講new HashMap(1024)更合適，不過上面annegu已經說過，即使是1000，hashmap也自動會將其設置為1024。 但是new HashMap(1024)還不是更合適的，因為0.75*1000 < 1000, 也就是說為了讓0.75 * size > 1000, 我們必須這樣new HashMap(2048)才最合適，既考慮了&的問題，也避免了resize的問題。 


4、key的hashcode與equals方法改寫 
在第一部分hashmap的數據結構中，annegu就寫了get方法的過程：首先計算key的hashcode，找到數組中對應位置的某一元素，然后通過key的equals方法在對應位置的鏈表中找到需要的元素。所以，hashcode與equals方法對於找到對應元素是兩個關鍵方法。 

Hashmap的key可以是任何類型的對象，例如User這種對象，為了保證兩個具有相同屬性的user的hashcode相同，我們就需要改寫hashcode方法，比方把hashcode值的計算與User對象的id關聯起來，那么只要user對象擁有相同id，那么他們的hashcode也能保持一致了，這樣就可以找到在hashmap數組中的位置了。如果這個位置上有多個元素，還需要用key的equals方法在對應位置的鏈表中找到需要的元素，所以只改寫了hashcode方法是不夠的，equals方法也是需要改寫滴~當然啦，按正常思維邏輯，equals方法一般都會根據實際的業務內容來定義，例如根據user對象的id來判斷兩個user是否相等。
在改寫equals方法的時候，需要滿足以下三點： 
(1) 自反性：就是說a.equals(a)必須為true。 
(2) 對稱性：就是說a.equals(b)=true的話，b.equals(a)也必須為true。 
(3) 傳遞性：就是說a.equals(b)=true，並且b.equals(c)=true的話，a.equals(c)也必須為true。 
通過改寫key對象的equals和hashcode方法，我們可以將任意的業務對象作為map的key(前提是你確實有這樣的需要)。

 

 

 

總結： 
        本文主要描述了HashMap的結構，和hashmap中hash函數的實現，以及該實現的特性，同時描述了hashmap中resize帶來性能消耗的根本原因，以及將普通的域模型對象作為key的基本要求。尤其是hash函數的實現，可以說是整個HashMap的精髓所在，只有真正理解了這個hash函數，才可以說對HashMap有了一定的理解。

 

 

 

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

什么時候擴容：當向容器添加元素的時候，會判斷當前容器的元素個數，如果大於等於閾值---即當前數組的長度乘以加載因子的值的時候，就要自動擴容啦。

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

我們分析下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鏈上的元素，通過重新計算索引位置后，有可能被放到了新數組的不同位置上。

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

這句話是重點----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對應的哈希與高位運算結果。

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

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

這個設計確實非常的巧妙，既省去了重新計算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 }