【java】HashMap扩容机制详解

╰+攻爆jí腚メ 2023-10-13 07:58 50阅读 0赞

#### 文章目录 ####

*  JDK1.7下的扩容机制
 *  JDK1.8下的扩容机制

## JDK1.7下的扩容机制 ##

JDK1.7下的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(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);

代码中可以看到，如果原有table长度已经达到了上限，就不再扩容了。

如果还未达到上限，则创建一个新的table，并调用transfer方法：

/**
         * Transfers all entries from current table to newTable.
         */
        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;              //注释1
                    if (rehash) {
        
                        e.hash = null == e.key ? 0 : hash(e.key);
                    }
                    int i = indexFor(e.hash, newCapacity); //注释2
                    e.next = newTable[i];                  //注释3
                    newTable[i] = e;                       //注释4
                    e = next;                              //注释5
                }
            }
        }

transfer方法的作用是把原table的Node放到新的table中，使用的是头插法，也就是说，新table中链表的顺序和旧列表中是相反的，在HashMap线程不安全的情况下，这种头插法可能会导致环状节点。

其中的while循环描述了头插法的过程，这个逻辑有点绕，下面举个例子来解析一下这段代码。

假设原有table记录的某个链表，比如table\[1\]=3，链表为3–>5–>7，那么处理流程为：

1，注释1：记录e.next的值。开始时e是table\[1\]，所以e3，e.next5，那么此时next==5。

![在这里插入图片描述][37d3d8f7b3444da084d118fddbc49d1d.png]

2，注释2，计算e在newTable中的节点。为了展示头插法的倒序结果，这里假设e再次散列到了newTable\[1\]的链表中。

3，注释3，把newTable \[1\]赋值给e.next。因为newTable是新建的，所以newTable\[1\]null，所以此时3.nextnull。

![在这里插入图片描述][1ddfa3a2f15741b3a247aaaf5541671f.png]

4，注释4，e赋值给newTable\[1\]。此时newTable\[1\]=3。

![在这里插入图片描述][eaf2f96c60d444759795504dc8a3c406.png]

5，注释5，next赋值给e。此时e==5。

![在这里插入图片描述][392c625fac7a46c28f7a3bad82556495.png]

此时newTable\[1\]中添加了第一个Node节点3，下面进入第二次循环，第二次循环开始时e==5。

1，注释1：记录e.next的值。5.next是7，所以next==7。  
![在这里插入图片描述][b9bf8cedee7143bb960b76eb29b118c3.png]

2，注释2，计算e在newTable中的节点。为了展示头插法的倒序结果，这里假设e再次散列到了newTable\[1\]的链表中。

3，注释3，把newTable \[1\]赋值给e.next。因为newTable\[1\]是3（参见上一次循环的注释4），e是5，所以5.next==3。

![在这里插入图片描述][81f82cb0552f49a3a9c48a11a8171eaa.png]

4，注释4，e赋值给newTable\[1\]。此时newTable\[1\]==5。

![在这里插入图片描述][f8ac5756aaf545e2b6b72898a16b8471.png]

5，注释5，next赋值给e。此时e==7。  
![在这里插入图片描述][3407eee3807540a386c9cf5588c13384.png]

此时newTable\[1\]是5，链表顺序是5–>3。

下面进入第三次循环，第二次循环开始时e==7。

1，注释1：记录e.next的值。7.next是NULL，所以next==NULL。

![在这里插入图片描述][2766e2e4b1e7414680056726e21886d2.png]

2，注释2，计算e在newTable中的节点。为了展示头插法的倒序结果，这里假设e再次散列到了newTable\[1\]的链表中。

3，注释3，把newTable \[1\]赋值给e.next。因为newTable\[1\]是5（参见上一次循环的注释4），e是7，所以7.next==5。

![在这里插入图片描述][6a5a552bea4b4ae48fcce061d04ad8b8.png]

4，注释4，e赋值给newTable\[1\]。此时newTable\[1\]==7。

![在这里插入图片描述][e38d985c825d4a369376b9c0f76f1909.png]

5，注释5，next赋值给e。此时e==NULL。

![在这里插入图片描述][625ca490edc04d83a733db24ffb18140.png]

此时newTable\[1\]是7，循环结束，链表顺序是7–>5–>3，和原链表顺序相反。

注意：这种逆序的扩容方式在多线程时有可能出现环形链表，出现环形链表的原因大概是这样的：线程1准备处理节点，线程二把HashMap扩容成功，链表已经逆向排序，那么线程1在处理节点时就可能出现环形链表。

另外单独说一下indexFor(e.hash, newCapacity);这个方法，这个方法是计算节点在新table中的下标用的，这个方法的代码如下：

/**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

计算下标的算法很简单，hash值 和 (length-1)按位与，使用length-1的意义在于，length是2的倍数，所以length-1在二进制来说每位都是1，这样可以保证最大的程度的散列hash值，否则，当有一位是0时，不管hash值对应位是1还是0，按位与后的结果都是0，会造成散列结果的重复。

## JDK1.8下的扩容机制 ##

JDK1.8对resize()方法进行很大的调整，JDK1.8的resize()方法如下：

final Node<K,V>[] resize() {
        
        Node<K,V>[] 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)                      //注释1
                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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
        
            for (int j = 0; j < oldCap; ++j) {
                                         //注释2
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
        
                    oldTab[j] = null;
                    if (e.next == null)                                        //注释3
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {
         // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
        
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                              //注释4
                                if (loTail == null)                            //注释5
                                    loHead = e;
                                else
                                    loTail.next = e;                           //注释6
                                loTail = e;                                    //注释7
                            }
                            else {
        
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                                          /注释8
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
        
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

代码解析：

1.  在resize()方法中，定义了oldCap参数，记录了原table的长度，定义了newCap参数，记录新table长度，newCap是oldCap长度的2倍（注释1），同时扩展点也乘2。
2.  注释2是循环原table，把原table中的每个链表中的每个元素放入新table。
3.  注释3，e.next==null，指的是链表中只有一个元素，所以直接把e放入新table，其中的e.hash & (newCap - 1)就是计算e在新table中的位置，和JDK1.7中的indexFor()方法是一回事。
4.  注释// preserve order，这个注释是源码自带的，这里定义了4个变量：loHead，loTail，hiHead，hiTail，看起来可能有点眼晕，其实这里体现了JDK1.8对于计算节点在table中下标的新思路：

> 正常情况下，计算节点在table中的下标的方法是：hash&(oldTable.length-1)，扩容之后，table长度翻倍，计算table下标的方法是hash&(newTable.length-1)，也就是hash&(oldTable.length\*2-1)，于是我们有了这样的结论：这新旧两次计算下标的结果，要不然就相同，要不然就是新下标等于旧下标加上旧数组的长度。

举个例子，假设table原长度是16，扩容后长度32，那么一个hash值在扩容前后的table下标是这么计算的：

![在这里插入图片描述][75fccd6078e9483887609e9e569de322.png]

hash值的每个二进制位用abcde来表示，那么，hash和新旧table按位与的结果，最后4位显然是相同的，唯一可能出现的区别就在第5位，也就是hash值的b所在的那一位，如果b所在的那一位是0，那么新table按位与的结果和旧table的结果就相同，反之如果b所在的那一位是1，则新table按位与的结果就比旧table的结果多了10000（二进制），而这个二进制10000就是旧table的长度16。

换言之，hash值的新散列下标是不是需要加上旧table长度，只需要看看hash值第5位是不是1就行了，位运算的方法就是hash值和10000（也就是旧table长度）来按位与，其结果只可能是10000或者00000。

所以，注释4处的e.hash & oldCap，就是用于计算位置b到底是0还是1用的，只要其结果是0，则新散列下标就等于原散列下标，否则新散列坐标要在原散列坐标的基础上加上原table长度。

理解了上面的原理，这里的代码就好理解了，代码中定义的四个变量：

> loHead，下标不变情况下的链表头
> 
> loTail，下标不变情况下的链表尾
> 
> hiHead，下标改变情况下的链表头
> 
> hiTail，下标改变情况下的链表尾

而注释4处的(e.hash & oldCap) == 0，就是代表散列下标不变的情况，这种情况下代码只使用了loHead和loTail两个参数，由他们组成了一个链表，否则将使用hiHead和hiTail参数。

其实e.hash & oldCap等于0和不等于0后的逻辑完全相同，只是用的变量不一样。

以等于0的情况为例，处理一个3–>5–>7的链表，过程如下：

首先处理节点3，e3，e.next5

1，注释5，一开始loTail是null，所以把3赋值给loHead。

2，注释7，把3赋值给loTail。

然后处理节点5，e5，e.next7

1，注释6，loTail有值，把e赋值给loTail.next，也就是3.next==5。

2，注释7，把5赋值给loTail。

现在新链表是3–>5，然后处理节点7，处理完之后，链表的顺序是3–>5–>7，loHead是3，loTail是7。可以看到，链表中节点顺序和原链表相同，不再是JDK1.7的倒序了。

代码到注释8这里就好理解了，

只要loTail不是null，说明链表中的元素在新table中的下标没变，所以新table的对应下标中放的是loHead，另外把loTail的next设为null

反之，hiTail不是null，说明链表中的元素在新table中的下标，应该是原下标加原table长度，新table对应下标处放的是hiHead，另外把hiTail的next设为null。

[37d3d8f7b3444da084d118fddbc49d1d.png]: https://img-blog.csdnimg.cn/37d3d8f7b3444da084d118fddbc49d1d.png
[1ddfa3a2f15741b3a247aaaf5541671f.png]: https://img-blog.csdnimg.cn/1ddfa3a2f15741b3a247aaaf5541671f.png
[eaf2f96c60d444759795504dc8a3c406.png]: https://img-blog.csdnimg.cn/eaf2f96c60d444759795504dc8a3c406.png
[392c625fac7a46c28f7a3bad82556495.png]: https://img-blog.csdnimg.cn/392c625fac7a46c28f7a3bad82556495.png
[b9bf8cedee7143bb960b76eb29b118c3.png]: https://img-blog.csdnimg.cn/b9bf8cedee7143bb960b76eb29b118c3.png
[81f82cb0552f49a3a9c48a11a8171eaa.png]: https://img-blog.csdnimg.cn/81f82cb0552f49a3a9c48a11a8171eaa.png
[f8ac5756aaf545e2b6b72898a16b8471.png]: https://img-blog.csdnimg.cn/f8ac5756aaf545e2b6b72898a16b8471.png
[3407eee3807540a386c9cf5588c13384.png]: https://img-blog.csdnimg.cn/3407eee3807540a386c9cf5588c13384.png
[2766e2e4b1e7414680056726e21886d2.png]: https://img-blog.csdnimg.cn/2766e2e4b1e7414680056726e21886d2.png
[6a5a552bea4b4ae48fcce061d04ad8b8.png]: https://img-blog.csdnimg.cn/6a5a552bea4b4ae48fcce061d04ad8b8.png
[e38d985c825d4a369376b9c0f76f1909.png]: https://img-blog.csdnimg.cn/e38d985c825d4a369376b9c0f76f1909.png
[625ca490edc04d83a733db24ffb18140.png]: https://img-blog.csdnimg.cn/625ca490edc04d83a733db24ffb18140.png
[75fccd6078e9483887609e9e569de322.png]: https://img-blog.csdnimg.cn/75fccd6078e9483887609e9e569de322.png