为什么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 这个值是为了在时间和空间成本之间达到一个较好的平衡点,既可以保证哈希表的性能表现,又能够充分利用空间。