HashMap的扩容机制

为什么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;
    }
  1. 获取原来的数组table、数组长度oldCap和阈值oldThr。
  2. 如果原来的数组table不为空,则根据扩容规则计算新数组长度newCap和新阈值newThr,然后将原数组中的元素复制到新数组中。
  3. 如果原来的数组 table 为空但阈值 oldThr 不为零,则说明是通过带参数构造函数创建的 HashMap ,此时将阈值作为新数组长度 newCap。
  4. 如果原来的数组table和阈值oldThr都为零,则说明是通过无参数构造函数创建的HashMap,此时将默认初始容量DEFAULT_INITIAL_CAPACITY(16)和默认负载因子 DEFAULT_LOAD_FACTOR(0.75)计算出新数组长度 newCap 和新阈值 newThr。
  5. 计算新阈值threshold,并将其赋值给成员变量threshold。
  6. 创建新数组newTab,并将其赋值给成员变量table。
  7. 如果旧数组oldTab不为空,则遍历旧数组的每个元素,将其复制到新数组中。
  8. 返回新数组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 这个值是为了在时间和空间成本之间达到一个较好的平衡点,既可以保证哈希表的性能表现,又能够充分利用空间。

相关推荐
IT技术分享社区1 分钟前
C#实战:使用腾讯云识别服务轻松提取火车票信息
开发语言·c#·云计算·腾讯云·共识算法
极客代码4 分钟前
【Python TensorFlow】入门到精通
开发语言·人工智能·python·深度学习·tensorflow
疯一样的码农11 分钟前
Python 正则表达式(RegEx)
开发语言·python·正则表达式
代码之光_198012 分钟前
保障性住房管理:SpringBoot技术优势分析
java·spring boot·后端
ajsbxi17 分钟前
苍穹外卖学习记录
java·笔记·后端·学习·nginx·spring·servlet
&岁月不待人&33 分钟前
Kotlin by lazy和lateinit的使用及区别
android·开发语言·kotlin
StayInLove36 分钟前
G1垃圾回收器日志详解
java·开发语言
对许40 分钟前
SLF4J: Failed to load class “org.slf4j.impl.StaticLoggerBinder“
java·log4j
无尽的大道44 分钟前
Java字符串深度解析:String的实现、常量池与性能优化
java·开发语言·性能优化
爱吃生蚝的于勒1 小时前
深入学习指针(5)!!!!!!!!!!!!!!!
c语言·开发语言·数据结构·学习·计算机网络·算法