为什么HashMap需要扩容机制？

类比于数组，数组一旦初始化后大小就无法改变了，所以就有了ArrayList 这种 " 动态数组 " ，可以自动扩容。
HashMap 的底层用的也是数组。向 HashMap 里不停地添加元素，当数组无法装载更多元素时，就需要对数组进行扩容，以便装入更多的元素；除此之外，容量的提升也会相应地提高查询效率，因为" 桶（坑） " 更多了嘛，原来需要通过链表存储的（查询的时候需要遍历），扩容后可能就有自己专属的" 坑位 " 了（直接就能查出来）即通过数组查询。

resize方法

HashMap 的扩容是通过 resize 方法来实现的， JDK 8 中融入了红黑树（链表长度超过 8 的时候，会将链表转化为红黑树来提高查询效率），对于新手来说，可能比较难理解。
为了减轻大家的学习压力，就还使用 JDK 7 的源码，搞清楚了 JDK 7 的，再看 JDK 8 的就会轻松很多。来看 Java7 的 resize 方法源码：

java 复制代码

// newCapacity为新的容量
void resize(int newCapacity) {
// 小数组，临时过度下
Entry[] oldTable = table;
// 扩容前的容量
int oldCapacity = oldTable.length;
// MAXIMUM_CAPACITY 为最大容量，2 的 30 次方 = 1<<30
if (oldCapacity == MAXIMUM_CAPACITY) {
// 容量调整为 Integer 的最大值 0x7fffffff（十六进制）=2 的 31 次方-1
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);
}

该方法接收一个新的容量newCapacity，然后将HashMap的容量扩大到newCapcacity。

首先，方法获取当前HashMap的旧数组oldTable和oldCapacity。如果旧容量已经达到HashMap支持的最大容量MAXIMUM_CAPACITY（2的30次方），就将新的阈值threshold调整为Integer.MAX_VALUE（2的31次方-1），这是因为HashMap的值不能超过MAXIMUM_CAPACITY。
因为 2,147,483,647 （ Integer.MAX_VALUE ） - 1,073,741,824 （ MAXIMUM_CAPACITY ） =
1,073,741,823 ，刚好相差一倍（ HashMap 每次扩容都是之前的一倍）。
接着方法创建出一个新的数组newTable，并将旧数组oldTable中的元素转移到新数组newTable中，转移过程是通过调用transfer方法来实现的。该方法遍历旧数组中的每个位置，并将这个位置中的键值对重新计算哈希值，将其插入到新数组对应的位置（相当于每一次扩容，都会对所有元素重新计算位置）
转移完成后，方法将HashMap内部的数组引用table指向新数组newTable，并重新计算阈值threshold。新的阈值是新容量newCapacity乘以负载因子loadFactor的结果，但如果计算结果超过了HashMap的支持的最大容量MAXIMUM_CAPACITY，则将阈值设置为
MAXIMUM_CAPACITY + 1 ，这是因为 HashMap 的元素数量不能超过 MAXIMUM_CAPACITY 。

新容量newCapacity

被初始化为原容量oldCapacity的两倍。然后，如果newCapacity超过了HashMap的容量限制 MAXIMUM_CAPACITY（2^30），就将 newCapacity 设置为 MAXIMUM_CAPACITY。如果newCapacity 小于默认初始容量 DEFAULT_INITIAL_CAPACITY（16），就将 newCapacity 设置为DEFAULT_INITIAL_CAPACITY。这样可以避免新容量太小或太大导致哈希冲突过多或者浪费空间。

Java8的时候，newCapacity的计算方式发生了一些细微的变化。

java 复制代码

int newCapacity = oldCapacity << 1;
if (newCapacity >= DEFAULT_INITIAL_CAPACITY && oldCapacity >=
DEFAULT_INITIAL_CAPACITY) {
if (newCapacity > MAXIMUM_CAPACITY)
newCapacity = MAXIMUM_CAPACITY;
} else {
if (newCapacity < DEFAULT_INITIAL_CAPACITY)
newCapacity = DEFAULT_INITIAL_CAPACITY;
}

注意， oldCapacity * 2 变成了 oldCapacity << 1 ，出现了左移（ << ）
以为运算符通常可以用来代替乘法运算和除法运算。例如，将0010011（39）左移两位就是10011100（156），刚好变成了原来的4倍。

Java 8 扩容

JDK8的扩容源代码：

java 复制代码

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//获取原来的数组table
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//获取数组长度oldcap
        int oldThr = threshold;//获取阈值oldThr
        int newCap, newThr = 0;
        if (oldCap > 0) {//如果原来的数组table不为空
            if (oldCap >= MAXIMUM_CAPACITY) {//超过最大值就不再扩充了，就只好随你碰撞区把
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&//没超过最大值，就扩充为原来的2倍
                     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);
        }
        //计算新的resize上限
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;//将新阈值赋值给成员变量threshold
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建新数组 newTab
        table = newTab;//将新数组newTab赋值给成员变量table
        if (oldTab != null) {//如果旧数组oldTab不为空
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> 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<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) {
                                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;
    }

获取原来的数组table、数组长度oldCap和阈值oldThr。
如果原来的数组table不为空，则根据扩容规则计算新数组长度newCap和新阈值newThr，然后将原数组中的元素复制到新数组中。
如果原来的数组 table 为空但阈值 oldThr 不为零，则说明是通过带参数构造函数创建的 HashMap ，此时将阈值作为新数组长度 newCap。
如果原来的数组table和阈值oldThr都为零，则说明是通过无参数构造函数创建的HashMap，此时将默认初始容量DEFAULT_INITIAL_CAPACITY（16）和默认负载因子 DEFAULT_LOAD_FACTOR（0.75）计算出新数组长度 newCap 和新阈值 newThr。
计算新阈值threshold，并将其赋值给成员变量threshold。
创建新数组newTab，并将其赋值给成员变量table。
如果旧数组oldTab不为空，则遍历旧数组的每个元素，将其复制到新数组中。
返回新数组newTab。

对HashMap的扩容机制进行小结

HashMap 的内部实现是通过一个数组和链表或红黑树的组合来实现的。当我们往 HashMap 中不断添加元素时，HashMap 会自动进行扩容操作（条件是元素数量达到负载因子（ load factor ）乘以数组长度时），以保证其存储的元素数量不会超出其容量限制。下面是 HashMap 的扩容机制：
1 、在进行扩容操作时， HashMap 会先将数组的长度扩大一倍，然后将原来的元素重新散列（这个词还是挺贴切的）到新的数组中。由于元素的散列位置是通过 key 的 hashcode 和数组长度取模得到的，因此在数组长度扩大后，元素的散列位置也会发生一些改变。
2 、在重新散列元素时，如果一个元素的散列位置发生了改变，那么它需要被移动到新的位置。如果新的位置上已经有元素了，那么这个元素就会被添加到链表的末尾，如果链表的长度超过了阈值（8个），那么它将会被转换成红黑树。
总之， HashMap 的扩容机制是通过增加数组长度和重新散列元素来实现的，它可以保证 HashMap 的存储容量足够大，同时也可以保证 HashMap 的存储效率和检索效率。但是，由于扩容操作需要耗费一定的时间和空间，因此我们需要在使用 HashMap 时，合理地设置初始容量和负载因子，以避免过多的扩容操作。

负载因子为什么是0.75？

HashMap 的加载因子（ load factor ，直译为加载因子，意译为负载因子）是指哈希表中填充元素的个数与桶的数量的比值，当元素个数达到负载因子与桶的数量的乘积时，就需要进行扩容。这个值一般选择 0.75 ，是因为这个值可以在时间和空间成本之间做到一个折中，使得哈希表的性能达到较好的表现。
如果负载因子过大，填充因子较多，那么哈希表中的元素就会越来越多地聚集在少数的桶中，这就导致了冲突的增加，这些冲突会导致查找、插入和删除操作的效率下降。同时，这也会导致需要更频繁地进行扩容，进一步降低了性能。
如果负载因子过小，那么桶的数量会很多，虽然可以减少冲突，但是在空间利用上面也会有浪费，因此选择0.75 是为了取得一个平衡点，即在时间和空间成本之间取得一个比较好的平衡点。
总之，选择 0.75 这个值是为了在时间和空间成本之间达到一个较好的平衡点，既可以保证哈希表的性能表现，又能够充分利用空间。