HashMap的扩容机制

原创 已于 2023-03-15 15:00:11 修改 · 933 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #链表 #哈希算法

于 2023-03-15 14:24:15 首次发布
HashMap在JDK1.7和1.8中的实现方式有所不同，1.7采用数组+链表，1.8引入了红黑树。扩容机制在两个版本中都涉及新数组的生成和元素的重新分布，1.8在处理链表和红黑树时更为优化。使用2的幂作为数组长度能有效减少碰撞。在高并发环境下，推荐使用线程安全的ConcurrentHashMap。

一、HashMap的底层

底层：采用数组+链表(JDK1.7)，采用数组+链表+红黑树(JDK1.8)。
容器：HashMap默认容器长度为16，扩容因子为0.75，以2的n次方扩容。

二、HashMap的扩容机制原理

1、JDK1.7版本扩容

①：先生成新数组；

②：遍历老数组中的每个位置上的链表上的每个元素；

③：获取每个元素的key，并基于新数组长度，计算出每个元素在新数组中的下标；

④：将元素添加到新数组中去；

⑤：所有元素转移完之后，将新数组赋值给HashMap对象的table属性。

2、JDK1.8版本扩容

①：先生成新数组；

②：遍历老数组中的每个位置上的链表或红黑树；

③：如果是链表，则直接将链表中的每个元素重新计算下标，并添加到新数组中去；

④：如果是红黑树，则先遍历红黑树，先计算出红黑树中每个元素对应在新数组中的下标位置；

a：统计每个下标位置的元素个数；

b：如果该位置下的元素个数超过了8，则生成一个新的红黑树，并将根节点添加到新数组的对应位置；

c：如果该位置下的元素个数没有超过8，那么则生成一个链表，并将链表的头节点添加到新数组的对应位置；

⑤：所有元素转移完了之后，将新数组赋值给HashMap对象的table属性。

三、HashMap底层JDK1.7到JDK1.8的变化

1、JDK1.8相较与JDK1.7在数组+链表的基础上添加了红黑树，加红黑树的目的时提高HashMap插入和查询的整体效率；

2、HashMap在jdk1.7中采用头插入法，在扩容时会改变链表中元素原本的顺序，以至于在并发场景下导致链表成环的问题。而在jdk1.8中采用尾插入法，在扩容时会保持链表元素原本的顺序

3、JDK1.7哈希算法比较复杂，存在各种右移与异或运算，JDK1.8进行了简化，因为复杂的哈希算法目的就是提高散列性，来提供HashMap的整体效率，而1.8新增了红黑树，所以可以适当的简化哈希算法，节省CPU资源。

四、HashMap扩容为什么是2的幂

h & (length-1)

减少碰撞的几率， 如果长度为16,length-1=15=01111
hash=1111 hash&01111=01111

如果长度为15，length-1=14=1110
hash =1111 hash&1110=1110
hash =1110 hash&1110=1110

两个就放到了一个位置，增加了碰撞，变成了链表，查询效率低
最后一位都为0,永远都不能存放元素了，增加了空间的浪费

五、HashMap线程不安全，高并发的时候用什么呢？

ConcurrentHashMap请添加图片描述

moernagedian
关注
HashMap扩容机制
小辉的编程学习记录
05-30 1313
触发条件：HashMap 的默认容量为 16 ，负载因子为 0.75，当集合中的元素超过容量与负载因子的乘积时，会引发扩容机制。我是小辉，24 届毕业生。当下是找工作ing，欢迎关注，持续分享。​ 如果红黑树的值小于 6 ，就会退化成链表。
hashMap的扩容机制
xinyihhh的博客
02-24 1797
capacity 即容量，默认16。 loadFactor 加载因子，默认是0.75（3/4,与容量相乘总是整数；设置太小频繁扩容，浪费空间；设置太大碰撞的概率高，查询效率慢） threshold 阈值。阈值=容量*加载因子。默认12。当元素数量size超过阈值时便会触发扩容。 空参数的构造函数：实例化的HashMap默认内部数组是null，即没有实例化。第一次调用put方法时，则会开始第一次初始化扩容，长度为16。 有参构造函数：用于指定容量。会根据指定的正整数找到不小于指定容量的2的幂数，.
jdk1.7HashMap扩容源码超详解析！
weixin_44154094的博客
06-26 526
jdk1.7 HashMap扩容源码详解
hashmap 扩容机制
学亮编程手记
05-23 2686
hashmap是一种基于数组和链表（或红黑树）的数据结构，它可以存储键值对的映射关系。hashmap的扩容机制是指当hashmap中的元素个数超过数组长度乘以负载因子时，就会重新分配一个更大的数组，并将原来的元素重新计算哈希值并插入到新的数组中。不同版本的Java实现了不同的扩容机制。
hashmap的扩容机制
weixin_45660035的博客
07-09 1050
hashmap的扩容机制
深入理解HashMap扩容机制（JDK7）
yanzigejuly的博客
07-26 2020
Hashmap的扩容需要满足两个条件：当前数据存储的数量（即size()）大小必须大于等于阈值；当前加入的数据发生了hash冲突。因为上面这两个条件，所以存在下面这些情况就是hashmap在存值的时候（默认大小为16，负载因子0.75，阈值12），可能达到最后存满16个值的时候，再存入第17个值才会发生扩容现象，因为前16个值，每个值在底层数组中分别占据一个位置，并没有发生hash碰撞。当然也有可能存储更多值（超多16个值，最多可以存27个值）都还没有扩容。
必知必会--HashMap扩容机制
星仔的博客
09-11 4480
前言 JDK1.8对HashMap进行的较大的改动，其中对HashMap的扩容机制进行了优化。 在JDK1.8前，在多线程的情况下，使用HashMap进行put操作会造成死循环。这是因为多次put操作会引发HashMap的扩容机制，HashMap的扩容机制采用头插法的方式移动元素，这样会造成链表闭环，形成死循环。JDK1.8中HashMap使用高低位来平移元素，这样保证效率的同时避免了多线程情...
聊一聊不同技术栈中hashmap扩容机制
拾忆的博客
12-04 633
前言 hash简介         作为后端开发，说HashMap是我们最经常接触到的数据结构都不为过，而HashMap如其名最主要依赖的算法就是hash散列算法来存储和读取数据。         以关键码值K为自变量，通过一定的函数关系h(K)(称为散列函数)，计算出对应的函数值来，把这个值解释为结点的存储地址，将结点存入到此存储单元中。检索时，用同样的方法计算地址，然后到相应的单元里去取要找的结点。通过散列方法可以对结点进行
【HashMap扩容机制】
我是Java程序员廖志伟，感谢朋友们的支持！
11-28 8470
我是廖志伟，一名Java开发工程师、幕后大佬社区创始人、Java领域优质创作者、优快云博客专家。拥有多年一线研发经验，研究过各种常见框架及中间件的底层源码，对于大型分布式、微服务、三高架构（高性能、高并发、高可用）有过实践架构经验。 博主：java_wxid 社区：幕后大佬 文章目录HashMap扩容机制 本文的大概内容： HashMap扩容机制 将(k1,v1)直接放入Node类型的数组中，这个数组初始化容量是16，默认的加载因子是0.75。 HashMap有两个参数影响其性能：初始容量和加载.
关于HashMap扩容机制
热门推荐
zhuzhianing的博客
04-05 5万+
HashMap的底层有数组 + 链表(红黑树)组成，数组的大小可以在构造方法时设置，默认大小为16，数组中每一个元素就是一个链表，jdk7之前链表中的元素采用头插法插入元素，jdk8之后采用尾插法插入元素，由于插入的元素越来越多，查找效率就变低了，所以满足某种条件时，链表会转换成红黑树。随着元素的增加，HashMap的数组会频繁扩容，如果构造时不赋予加载因子默认值，那么负载因子默认值为0.75,数组扩容的情况如下: 1:当添加某个元素后，数组的总的添加元素数大于了 数组长度 * 0.75(默认,也可自己设
HashMap 的扩容机制
yueyue0609的博客
06-07 620
4、如果原来的数组 table 和阈值 oldThr 都为零，则说明是通过无参数构造方法创建的 HashMap，此时将默认初始容量 DEFAULT_INITIAL_CAPACITY（16）和默认负载因子 DEFAULT_LOAD_FACTOR（0.75）计算出新数组长度 newCap 和新阈值 newThr。除此之外，扩容也能提高查询效率，因为数组变大，以往需要链表储存的键值对（链表查询有时候要遍历，时间复杂度为O(n)），有了自己的位置。6、创建新数组 newTab，并将其赋值给成员变量 table。
HashMap(3)进阶篇--HashMap扩容机制
mgl934973491的博客
03-05 9230
1.什么是resize：resize就是重新计算容量；当我们不断的向HashMap对象里不停的添加元素时，HashMap对象内部的数组就会出现无法装载更多的元素，这是对象就需要扩大数组的长度，以便能装入更多的元素；当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组；就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。2.什么时候需要resize():当向容器添加元
HashMap 扩容机制
认知 行动 坚持
09-07 538
HashMap在1.7 和1.8 做了比较大的改变 1.7之前使用的就是数组 + 链表，它数据节点是一个Entry 节点，它的一个内部类；1.7之前它的数据插入过程是使用了头插入，头插入法虽然效率比较高，但在resize拓容过程时，反复调用一个transfer的方法，把里面的一些Entry进行一个rehash，可能会造成链表的循环，就可能在下一次Get的时候出现一个死循环的情况；1.7没有加锁，也可能在多线程并发的情况下，数据不能保证它是一个安全的，就是我push的进去的值，取出来还是我push进去的一个
HashMap的数据结构深入学习
weixin_50055999的博客
04-21 1692
本文深入解析了Java HashMap的核心机制，主要包含以下内容：1. 数据结构演变：从JDK1.8前的数组+链表到JDK1.8引入红黑树（链表长度>8且数组容量≥64时转换），优化查询效率；2. 关键参数：默认初始容量16、负载因子0.75、树化阈值8和链化阈值6；3. 扩容机制：当元素数量超过capacity*loadFactor时触发，容量翻倍并重新哈希；4. 哈希冲突处理：通过拉链法和红黑树解决冲突，保证O(1)平均时间复杂度；5. 迭代安全：fail-fast机制防止并发修改，比较modC
Hashmap扩容机制
最新发布
06-23
### Java HashMap 扩容机制原理与源码分析 HashMap 的扩容机制是其性能优化的重要部分之一，主要发生在当前存储的元素数量超过负载因子与容量的乘积时。以下是关于 HashMap 扩容机制的工作原理和源码分析： #### 1. 扩容触发条件 当向 HashMap 中插入键值对时，如果当前的键值对数量（即 size）超过了阈值（threshold），就会触发扩容操作。阈值计算公式为： \[ \text{threshold} = \text{capacity} \times \text{loadFactor} \] 其中，`capacity` 是 HashMap 的当前容量，`loadFactor` 是负载因子，默认值为 0.75[^1]。 #### 2. 扩容过程 扩容的核心思想是将原数组中的所有元素重新映射到新的数组中，新数组的容量通常是原数组容量的两倍。具体步骤如下： - **创建新数组**：创建一个容量为原数组两倍的新数组。 - **重新计算索引**：对于原数组中的每个节点，重新计算其在新数组中的位置。 - **迁移数据**：将原数组中的所有节点迁移到新数组中。 #### 3. 源码分析 以下是对 JDK 1.8 中 HashMap 扩容方法 `resize()` 的源码分析： ```java 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; // 新阈值为旧阈值的两倍 } } else if (oldThr > 0) { newCap = oldThr; } else { newCap = DEFAULT_INITIAL_CAPACITY; // 默认初始容量为16 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 默认负载因子为0.75 } threshold = newThr; // 更新阈值 @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 创建新数组 table = newTab; // 将新数组赋值给 table if (oldTab != null) { 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 { // 多个链表节点需要重新分配 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; } ``` #### 4. 关键点解析 - **为什么扩容为原来的两倍**：扩容为原来的两倍可以减少频繁的扩容操作，同时保持较低的哈希冲突概率[^2]。 - **为什么数组长度必须是 2 的幂次方**：通过与 `(n-1)` 进行按位与运算代替取模运算，提升效率。 - **红黑树优化**：当链表长度超过一定阈值（默认为 8）时，链表会转换为红黑树，以提高查找效率[^3]。 #### 5. 线程安全性 JDK 1.8 中的 HashMap 在扩容时避免了 JDK 1.7 中可能出现的死循环问题，但仍不是线程安全的。在并发环境下使用 HashMap 可能会导致数据丢失或结构损坏[^3]。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值