java之HashMap源码(三)

这篇主要讲解HashMap的扩容

HashMap的数组的初始化和扩容都是在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) //双倍扩容
            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) { //遍历数组
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //如果next为空，说明既不是链表也不是数组，直接赋值
                if (e.next == null) 
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode) //如果是红黑树
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 链表
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    //链表的迁移，使用了高低位算法算出节点在新数组的位置
                    do {
                        next = e.next;
                        //当前节点的hash值和旧数组的大小进行与运算==0，则判定为低位
                        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;
}

在进行put操作时，如果数组的大小为空或者大于等于阈值(数组大小 * 装载因子)就会调用resize方法。如果数组为空，resize方法会初始化HashMap数组大小，默认的大小为16，装载因子是0.75。如果数组不为空，首选会判断数组容量是否大于等于最大容量，如果是，则直接返回，不再进行扩容，否则进行双倍扩容。数组进行扩容之后，进行元素迁移操作。

值得注意的是：链表的迁移，使用了高低位算法算出节点在新数组的位置，如果当前节点的hash值和旧数组的大小进行与运算==0，则判定为低位，否则判定为高位。当节点为低位节点，低位节点在新数组的位置与在旧数组的位置相同；当节点为高位节点，高位节点在新数组的位置就是在旧数组的位置相同+旧数组容量大小。