簡單的介紹和原始碼分析

先看put操作的原始碼：

public V put(K key, V value) {
　　　　//判斷當前Hashmap(底層是Entry陣列)是否存值（是否為空陣列）
　　　　if (table == EMPTY_TABLE) {
　　　　　　inflateTable(threshold);//如果為空，則初始化
　　　　}
　　　　
　　　　//判斷key是否為空
　　　　if (key == null)
　　　　　　return putForNullKey(value);//hashmap允許key為空
　　　　
　　　　//計算當前key的雜湊值　　　　
　　　　int hash = hash(key);
　　　　//通過雜湊值和當前資料長度，算出當前key值對應在陣列中的存放位置
　　　　int i = indexFor(hash, table.length);
　　　　for (Entry<K,V> e = table[i]; e != null; e = e.next) {
　　　　　　Object k;
　　　　　　//如果計算的雜湊位置有值（及hash衝突），且key值一樣，則覆蓋原值value，並返回原值value
　　　　　　if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
　　　　　　　　V oldValue = e.value;
　　　　　　　　e.value = value;
　　　　　　　　e.recordAccess(this);
　　　　　　　　return oldValue;
　　　　　　}
　　　　}
 
　　　　modCount++;
　　　　//存放值的具體方法
　　　　addEntry(hash, key, value, i);
　　　　return null;
}
 

拓展一下：從這裡可以看出來map的核心其實就是陣列

肯定是put到一定量的時候才會觸發擴容機制，那麼我現在來看下addEntry這個方法

void addEntry(int hash, K key, V value, int bucketIndex) {
　　　　//1、判斷當前個數是否大於等於閾值
　　　　//2、當前存放是否發生雜湊碰撞
　　　　//如果上面兩個條件否發生，那麼就擴容
　　　　if ((size >= threshold) && (null != table[bucketIndex])) {
　　　　　　//擴容，並且把原來陣列中的元素重新放到新陣列中
　　　　　　resize(2 * table.length);
　　　　　　hash = (null != key) ? hash(key) : 0;
　　　　　　bucketIndex = indexFor(hash, table.length);
　　　　}
 
　　　　createEntry(hash, key, value, bucketIndex);
　　}
 

從引數看可以看出來一次預設擴容就是兩倍，還是比較慷慨的

現在進入核心resize方法方法內部：

void resize(int newCapacity) {
　　　　Entry[] oldTable = table;
　　　　int oldCapacity = oldTable.length;
　　　　//判斷是否有超出擴容的最大值，如果達到最大值則不進行擴容操作
　　　　if (oldCapacity == MAXIMUM_CAPACITY) {
　　　　　　threshold = Integer.MAX_VALUE;
　　　　　　return;
　　　　}
 
　　　　Entry[] newTable = new Entry[newCapacity];
　　　　// transfer()方法把原陣列中的值放到新陣列中
　　　　transfer(newTable, initHashSeedAsNeeded(newCapacity));
　　　　//設定hashmap擴容後為新的陣列引用
　　　　table = newTable;
　　　　//設定hashmap擴容新的閾值
　　　　threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
　　}
 

這個方法做了幾件事情，

1.判斷是否能擴容，看出來擴容的嘴最大值就是integer的最大值（2的31次方減一 ）

2.當發現數量還沒有到integer最大值時候，建立一個一定長度的陣列，是2×需要擴容的陣列的長度

3.呼叫方法transfer（）作用就是將原來的陣列新增到新的陣列中，最耗費資源的應該就是在這一步具體實現方法可以看下：

void transfer(Entry[] newTable, boolean rehash) {
　　　　int newCapacity = newTable.length;
　　　　for (Entry<K,V> e : table) {
　　　　　　while(null != e) {
　　　　　　　　Entry<K,V> next = e.next;
　　　　　　　　if (rehash) {
　　　　　　　　　　e.hash = null == e.key ? 0 : hash(e.key);
　　　　　　　　}
　　　　　　　　//通過key值的hash值和新陣列的大小算出在當前陣列中的存放位置
　　　　　　　　int i = indexFor(e.hash, newCapacity);
　　　　　　　　e.next = newTable[i];
　　　　　　　　newTable[i] = e;
　　　　　　　　e = next;
　　　　　　}
　　　　}
}

總結：

Hashmap的擴容需要滿足兩個條件：當前資料儲存的數量（即size()）大小必須大於等於閾值；當前加入的資料是否發生了hash衝突。

因為上面這兩個條件，所以存在下面這些情況

當數量滿足：就是hashmap在存值的時候（預設大小為16，負載因子0.75，閾(這個讀yu第四聲)值12），可能達到最後存滿16個值的時候，再存入第17個值才會發生擴容現象，因為前16個值，每個值在底層陣列中分別佔據一個位置，並沒有發生hash碰撞。

當hash碰撞滿足：當然也有可能儲存更多值（超多16個值，最多可以存26個值）都還沒有擴容。原理：前11個值全部hash碰撞，存到陣列的同一個位置（這時元素個數小於閾值12，不會擴容），後面所有存入的15個值全部分散到陣列剩下的15個位置（這時元素個數大於等於閾值，但是每次存入的元素並沒有發生hash碰撞，所以不會擴容），前面11+15=26，所以在存入第27個值的時候才同時滿足上面兩個條件，這時候才會發生擴容現象。

至於這些數字怎麼來的感興趣的小夥伴自行拓展