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

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

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

我們分析下resize的原始碼，鑑於JDK1.8融入了紅黑樹，較複雜，為了便於理解我們仍然使用JDK1.7的程式碼，好理解一些，本質上區別不大，具體區別後文再說。

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

1. void transfer(Entry[] newTable) {  
2.     Entry[] src = table;                   //src引用了舊的Entry陣列
3.     int newCapacity = newTable.length;  
4.     for (int j = 0; j < src.length; j++) { //遍歷舊的Entry陣列
5.         Entry<K, V> e = src[j];             //取得舊Entry陣列的每個元素
6.         if (e != null) {  
7.             src[j] = null;//釋放舊Entry陣列的物件引用（for迴圈後，舊的Entry陣列不再引用任何物件）
8.             do {  
9.                 Entry<K, V> next = e.next;  
10.                 int i = indexFor(e.hash, newCapacity); //！！重新計算每個元素在陣列中的位置
11.                 e.next = newTable[i]; //標記[1]
12.                 newTable[i] = e;      //將元素放在陣列上
13.                 e = next;             //訪問下一個Entry鏈上的元素
14.             } while (e != null);  
15.         }  
16.     }  
17. }  

1. staticint indexFor(int h, int length) {  
2.     return h & (length - 1);  
3. }  

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的註釋。

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