HashMap擴容機制原始碼分析

　　1、具體看原始碼之前，我們先簡單的說一下HashMap的底層資料結構

　　1、HashMap底層的資料結構是 陣列 + 連結串列 + 紅黑樹

　　2、我們需要先了解一下HashMap底層的兩個變數

　　2-1：loadFactor: 載入因子，預設是0.75，這個值是經過反覆測試最合適的值。

　　2-2：threshold: 當map裡面的資料大於這個threshold就會進行擴容

　　注:詳細瞭解loadFactor點選這裡

　　2、現在來看一下HashMap的構造方法

　　hashMap的構造方法有4個。

　　1、空參構造方法，這個時候載入因子為預設的0.75，並且不會建立空間。

　　threshold 為0

　　陣列為null

　　public HashMap() {

　　this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

　　}

　　2、給定初始化容量大小，這個構造方法裡面會直接去呼叫第三個構造方法

　　threshold 已經有值了

　　陣列為null

　　public HashMap(int initialCapacity) {

　　this(initialCapacity, DEFAULT_LOAD_FACTOR);

　　}

　　3、給定初始化大小，和載入因子。

　　1、其實並不建議修改預設的載入因子。當然除非你很瞭解這裡面的邏輯找到一個適合自己這個專案的載入因子

　　2、先是判斷你給的初始化容量是否合法，如果合法的話就用這個初始化容量計算出 threshold

　　threshold 已經有值了

　　陣列為null

　　public HashMap(int initialCapacity, float loadFactor) {

　　if (initialCapacity < 0)

　　throw new IllegalArgumentException("Illegal initial capacity: " +

　　initialCapacity);

　　if (initialCapacity > MAXIMUM_CAPACITY)

　　initialCapacity = MAXIMUM_CAPACITY;

　　if (loadFactor <= 0 || Float.isNaN(loadFactor))

　　throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

　　this.loadFactor = loadFactor;

　　this.threshold = tableSizeFor(initialCapacity);

　　}

　　4、把一個Map作為引數傳遞過來，載入因子適應預設的0.75。把其它Map轉化成HashMap

　　threshold 已經有值了

　　陣列為也不為空了

　　public HashMap(Map m) {

　　this.loadFactor = DEFAULT_LOAD_FACTOR;

　　putMapEntries(m, false);

　　}

　　final void putMapEntries(Map m, boolean evict) {

　　int s = m.size();

　　if (s > 0) {

　　if (table == null) { // pre-size

　　float ft = ((float)s / loadFactor) + 1.0F;

　　int t = ((ft < (float)MAXIMUM_CAPACITY) ?

　　(int)ft : MAXIMUM_CAPACITY);

　　if (t > threshold)

　　threshold = tableSizeFor(t);

　　}

　　else if (s > threshold)

　　resize();

　　for (Map.Entry e : m.entrySet()) {

　　K key = e.getKey();

　　V value = e.getValue();

　　putVal(hash(key), key, value, false, evict);

　　}

　　}

　　}

　　3、讓我們看看是HashMap是怎麼進入擴容的

　　3-1：我們先從 put() 這個方法說起

　　public V put(K key, V value) {

　　return putVal(hash(key), key, value, false, true);

　　}

　　這個put方法底層是呼叫了一個叫 putVal 的方法，但是在這之前我們有必要看一下hash()這個方法。

　　直接使用 物件.hashCode(), 可能會出現重複，所以這個hash是對生成的hashcode進行一下擾亂，讓其重複性更低。

　　從這裡也可以看到，HashMap只允許一個null鍵

　　static final int hash(Object key) {

　　int h;

　　return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

　　}

　　3-2：下面我們看一下這個putVal方法

　　putVal原始碼：

　　final V putVal(int hash, K key, V value, boolean onlyIfAbsent,

　　boolean evict) {

　　Node[] tab; Node 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 {

　　Node e; K k;

　　if (p.hash == hash &&

　　((k = p.key) == key || (key != null && key.equals(k))))

　　e = p;

　　else if (p instanceof TreeNode)

　　e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);

　　else {

　　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;

　　}

　　if (e.hash == hash &&

　　((k = e.key) == key || (key != null && key.equals(k))))

　　break;

　　p = e;

　　}

　　}

　　if (e != null) { // existing mapping for key

　　V oldValue = e.value;

　　if (!onlyIfAbsent || oldValue == null)

　　e.value = value;

　　afterNodeAccess(e);

　　return oldValue;

　　}

　　}

　　++modCount;

　　if (++size > threshold)

　　resize();

　　afterNodeInsertion(evict);

　　return null;

　　}

　　這個原始碼看起來還是有點複雜的，考慮到很多同學可能和我一樣資料結構並不是太好。我把它簡化一下，提取裡面的思想便於理解

　　final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {

　　Node[] tab; Node p; int n, i;

　　if ((tab = table) == null || (n = tab.length) == 0){

　　// 當資料為null或者長度為0的時候進行擴，併發擴後的長度返回給n(前面說了hashMap底層最開始是個陣列)

　　n = (tab = resize()).length;

　　}

　　// 之前可能有同學有疑問，hashcode那麼長，為啥預設HashMap陣列預設長度是16。其實最後的下標是經過處理的 (n - 1) & hash

　　if ((p = tab[i = (n - 1) & hash]) == null){

　　// 如果當前陣列的下標，並沒有資料，也就是說當前新增的資料是第一個，那就直接加入進去就好了。不需要排序啥的

　　tab[i] = newNode(hash, key, value, null);

　　}

　　else {

　　// 找到了資料下標，並且裡面的已經有資料了，

　　// 這裡就要找到當前資料的位置屬於那裡並加入進去，

　　// 還要判斷當前長度是否大於我們設定的長度，大於就要把鏈轉化成紅黑樹便於查詢

　　}

　　++modCount;

　　// 判斷當前長度是否大於需要擴的長度，其實也好理解，陣列是可以裝滿的，但是鏈不可能滿呀，但是長度超過一定的長度的時候鏈的效能就會很差了

　　if (++size > threshold)

　　resize();

　　// 節點插入後的操作，目前這個沒有任何實現，裡面是個空方法

　　afterNodeInsertion(evict);

　　return null;

　　}

　　3-3：總結進入擴容的兩種情況

　　新增一個資料的時候，底層陣列為空的時候

　　新增一個資料結束後，判斷當前資料個數是否大於threshold (需要擴容)的大小，大於就進行擴容

　　注：因為資料是具體新增到陣列裡面的連結串列，所以不存在陣列越界情況。

　　4、具體看一下擴容程式碼

　　擴容原始碼：

　　final Node[] resize() {

　　Node[] 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;

　　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 = newThr;

　　@SuppressWarnings({"rawtypes","unchecked"})

　　Node[] newTab = (Node[])new Node[newCap];

　　table = newTab;

　　if (oldTab != null) {

　　for (int j = 0; j < oldCap; ++j) {

　　Node e;

　　if ((e = oldTab[j]) != null) {

　　oldTab[j] = null;

　　if (e.next == null)

　　newTab[e.hash & (newCap - 1)] = e;

　　else if (e instanceof TreeNode)

　　((TreeNode)e).split(this, newTab, j, oldCap);

　　else { // preserve order

　　Node loHead = null, loTail = null;

　　Node hiHead = null, hiTail = null;

　　Node next;

　　do {

　　next = e.next;

　　if ((e.hash & oldCap) == 0) {

　　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.next = null;

　　newTab[j] = loHead;

　　}

　　if (hiTail != null) {

　　hiTail.next = null;

　　newTab[j + oldCap] = hiHead;

　　}

　　}

　　}

　　}

　　}

　　return newTab;

　　}

　　同樣的把原始碼進行一下簡單的分享，去除複雜的內容

　　// 這個擴容方法就是

　　// 1、找到新的容量大小和新的threshold大小

　　// 2、把舊的資料全部複製到新的陣列中去

　　final Node[] resize() {

　　Node[] 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){

　　newCap = oldThr;

　　}

　　// 使用空參構造方法第一次擴容進入，使用引數為map的構造方法，第一次也會進入這個擴容方法

　　else {

　　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 = newThr;

　　@SuppressWarnings({"rawtypes","unchecked"})

　　Node[] newTab = (Node[])new Node[newCap];

　　table = newTab;

　　// 把舊的資料全部複製到新的陣列中去

　　if (oldTab != null) {

　　//

　　}

　　return newTab;

　　}

　　5、總結(面試的時候：請你說一下HashMap的擴容)：

　　HashMap底層資料結構是 陣列 + 連結串列 + 紅黑樹

　　真正的資料是儲存在連結串列中的，連結串列的長度是無限的。所以這時候就引入一個變數 threshold

　　當第一次向map裡面新增資料，或新增完資料後的大小，大於 threshold的大小，這時候就會進行擴容

　　先說一下非第一次擴容，這個相對簡單點

　　1、如果當前的容量大小，大於等於HashMap規定的最大容量的話，直接讓threshold等於Integer的最大值，就可以了。

　　2、一般情況當前陣列長度是不會大於最大值的，所以這時候新的陣列長度等於舊陣列的2倍。如果新的陣列長度小於HashMap規定的最大值，並且舊的陣列長度也大於等於HashMap規定的預設大小容量大小(16)，那麼threshold擴大2倍，否則不變

　　非第一次擴容

　　1、HashMap，有四個構造方法。空參構造方法的threshold變數是0，其它構造方法threshold都有初始值。

　　2、當舊的threshold大於0的時候，新的陣列容量大小就等於舊的threshold大小。新的threshold大小等於載入因子新的陣列大小。

　　3、當舊的threshold不大於0的時候，新的陣列大小就等於預設的大小(16)，新的threshold大小，就等於預設的容量大小預設的載入因子大小

　　上面已經得出了新的容量大小和新的threshold的大小，後面只需要用新容量大小建立一個陣列，把舊陣列的內容複製進去就好了。