JDK1.8HashMap的resize()方法

最新推荐文章于 2024-04-03 08:11:00 发布
最新推荐文章于 2024-04-03 08:11:00 发布
阅读量708 收藏
点赞数
分类专栏： Java8 JavaAPI HashMap
本文详细探讨了HashMap的重要性和其内部实现机制。从初始化到添加元素，深入解析HashMap的每个关键步骤，帮助读者掌握这一数据结构的核心原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转载自woniu4
是HashMap非常重要的方法,在集合初始化、添加等操作中都使用到,需要仔细研究

源码-JDK1.8HashMap扩容方法resize()解析
CodeDabaicai的博客
12-13 393
1、准备知识 HashMap的底层数据结构 Java语言的基本数据结构可以分为两种，一种是数组，另一种的模拟指针/引用，Java语言中涉及到的数据结构都是这两种的扩充。JDK1.8之前HashMap是数组+链表结合的链表散列。JDK1.8在解决哈希冲突上发生了变化，当链表长度大于阈值/默认8的时候，会将链表转化为红黑树，减少搜索时间。 hash算法 我们希望HashMap的元素位置尽量分散，最好是每个位置只有一个元素，这样用hash算法求得该位置后可以直接返回结果，不用再遍历链表/红黑树。 H
JDK1.8HashMap底层实现原理
weixin_43145539的博客
05-27 4594
hashmap是我们开发中用的最常见的集合之一，但是我们是否有了解过他的底层呢？这篇文章我将带您了解一下hashmap的底层 位运算 在学习hashmap底层原理的时候，我们必须要掌握位运算，别问为什么，往下面看自然知晓 ...
JDK1.8中HashMap的resize()方法详解
frozenpenguin的博客
12-29 1802
resize()方法的代码比较长，我们先用文字来总结一下该方法具体做了什么。首先记录当前数组信息，当前数组、数组长度还有扩容阈值。接着就到了一个if-elseif-else的代码块，这些就是用来判断当前是进行初始化操作还是扩容操作，如果是扩容操作则需要进行双倍扩容，如果是初始化数组则需要设置数组容量。如果是扩容操作或者初始化的时候用户指定了初始容量，则要⽤新数组的大小重写计算扩容阈值重新生成一个数组（无论是扩容操作还是初始化操作都需要）。
hashMap resize原理 jdk1.8
hhhhhhhhh的博客
11-12 516
jdk1.7与1.8之间的hashMap区别之一就是在于resize()方法解决了1.7多线程状态下扩容可能出现的链表死循环的问题，并取消reshash的操作，提升了运行时间。 使用idea的快捷键 CTRL+F12 打开hashMap的代码，搜索resize得到如下代码： final Node<K,V>[] resize() { Node<K,V>[] o...
HashMap (jdk1.8)resize()方法详细注释
汉堡配大蒜
07-05 242
//hashMap初始化兼扩容 final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; //创建node数组oldTab，并将hashMap的成员数组table 赋值给oldTab; int oldCap = (oldTab == null) ? 0 : oldTab.length; //获取oldTab数组的长度，如果直接int oldCap = oldTab.length,当t...
HashMap1.8 resize()
weixin_44049210的博客
12-11 911
HashMap1.8中resize过程，扩容后索引重排流程
jdk1.8 hashmap
02-07 413
1、HashMap概述 在JDK1.8之前，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的节点都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。 下图中代表jdk1.8之前的hashmap结构，左边部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的...
JDK1.8 HashMap扩容
Naker_的博客
03-28 1898
说在前边 JDK1.8中的HashMap较于前代有了较大的变更，主要变化在于扩容机制的改变。在JDK1.7及之前HashMap在扩容进行数组拷贝的时候采用的是头插法，因此会造成并发情景下形成环状链表造成死循环的问题。JDK1.8中改用了尾插法进行数组拷贝，修复了这个问题。同时JDK1.8开始HashMap改用数组+链表/红黑树组合的数据结构来提高查询效率，降低哈希冲突产生的链表过长导致的查询效率减缓现象。 本文的主要内容是对JDK1.8中的扩容机制与前代进行比较，分析其异同。 准备 数组大小的计算 在JDK
JDK1.8 HashMap详解
浅汐
12-08 911
HashMap是一个散列表，它存储的内容是键值对(key-value)映射。 1 定义 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { } 由HashMap定义可以看出 1） HashMap&l...
JDK1.8HashMap源码解析之resize扩容操作
weixin_43608392的博客
11-08 414
一、概述 1.根据不同情况对容量以及阈值进行赋值 2.如果旧哈希表不为空，创建新哈希表准备扩容 3.遍历旧哈希表 （1）只有一个头节点的链表，将该头节点重新结算哈希放到新的哈希表 （2）红黑树 （3）遍历链表，如果扩容后的下标是否扩容前的相等， JDK1.8关于HashMap扩容时的resize()方法中(e.hash & oldCap) == 0算法讲解.将该节点放到新的哈希表，否则将下标加上扩容前容量放到新的哈希表 一、源码解析 final HashMap.Node<K,V&g
HashMap之resize()方法源码解读.docx
06-17
HashMap之resize()方法源码解读，分两部分概述扩容方法涉及到的处理：创建新数组，将旧数组元素转移到新数组上
JDK1.8 HashMap 扩容 resize
kl_Dreaming的博客
09-15 320
之前一直没了解过HashMap的扩容机制，最近在面试中被问到，没有回答上来，下来看了下它的实现方式，主要是其中的resize()方法，下面着重看下这个方法。 final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; i
jdk1.8扩容 resize() 笔记
qq_40274514的博客
04-03 436
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; // 初始化节点,第一次为null,第二次16 int oldCap = (oldTab == null) ? 0 : oldTab.length; // 第二次16 int oldThr = threshold; // 第一次12 int newCap, newThr = 0; if (..
JDK1.8源码 resize()解析
IT_datouer的博客
07-14 235
final HashMap.Node<K,V>[] resize() { HashMap.Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; //threshold在table未初始化时存储的是构造方法中tableSizeFor(initialCapacity)的值，如果未带参数ini
1.8HashMap源码解析之resize方法
qq_43552690的博客
04-03 848
(1) HashMap的大小总是2的n次方，这样在扩容的时候，链表中的结点只会被移动新数组的两个下标，一个就是与旧的数组下标相同的位置，另一个下标就是在旧数组的下标加上旧数组的长度，怎么判断是这两个下标的哪个呢？将hash值与旧数组的长度进行与运算，为0，则在新数组的下标与旧数组的下标相同，为1，则在新数组的下标为旧数组下标加上旧数组长度。第一步：e指针指向当前遍历到的结点，假设k1与旧数组长度与之后的结果为0，则将loHead和loTail两个指针指向k1结点，如下图所示，并向e指针下移到k2结点。
深入理解HashMap底层原理剖析(JDK1.8) 扩容方法resize()
MayMatrix 的博客
05-29 1933
接下来会从以下几个方面介绍 HashMap 源码相关知识： 　　1、HashMap 存储结构 　　2、HashMap 各常量、成员变量作用 　　3、HashMap 几种构造方法 　　4、HashMap put 及其相关方法 　　5、HashMap get 及其相关方法 　　6、HashMap remove 及其相关方法 　　7、HashMap 扩容方法　resize() 　　介绍方法时会包含方法实现相关细节。 　　先来看一下 HashMap 的继承图： 　　 HashMap 根据键的
JDK1.8---HashMap的resize()扩容方法源码详解
qq_36856024的博客
08-17 4158
JDK1.8---HashMap的resize(）扩容方法源码详解resize()方法触发时机下面开始根据源码介绍HashMap的扩容原理下面进行分步分析扩容 resize()方法触发时机 首先总结一下JDK1.8的HashMap都在什么时候触发resize()方法，根据阅读源码总结了三个时机触发扩容，这里只做介绍，后面根据源码详细分析 HashMap是由数组+链表+红黑树构成的，数组就称之为桶了...
hashMap1.8 resize（）个人解读
weixin_42474495的博客
04-08 407
参考文章： https://blog.csdn.net/u013494765/article/details/77837338 https://blog.csdn.net/cadi2011/article/details/104851355 https://blog.csdn.net/weixin_39667787/article/details/86678215 目录如何确定元素在数组中的索引下标?resize方法为什么扩容后，元素新下标为原数组下标或者原数组下标+原数组容量? 如何确定元素在数组中的.
JDK1.8 HashMap中resize()方法解释
journey_fan的专栏
04-25 3261
JDK1.8 HashMap中resize()方法解析 * 初始化或者是将table大小加倍。如果为空，则按threshold分配空间，否则，加倍后，每个容器中的元素在新table中要么呆在原索引处，要么有一个2的次幂的位移 * @return the table */ final Node[] resize() { Node[] oldTab
jdk1.8 hashmap的实现原理
最新发布
06-25
<think>我们正在分析JDK1.8中HashMap的实现原理。根据引用内容，HashMap基于哈希表实现，使用键值对存储，允许null键和null值，非线程安全，存储无序。在JDK1.8中，HashMap由数组+链表+红黑树组成，当链表长度超过阈值（默认为8）且数组长度大于64时，链表转换为红黑树，以提高查询效率。首先，我们需要了解HashMap的几个关键点：1.底层结构：数组（称为桶数组）+链表/红黑树2.哈希函数：通过键的hashCode计算索引位置3.解决冲突：拉链法（链表），当链表过长时转为红黑树4.扩容机制：当元素数量超过阈值（容量*负载因子）时，扩容为原来的2倍接下来，我们将从以下几个方面分析：1.关键常量与变量2.哈希函数3.put方法流程4.扩容机制5.树化与反树化条件###1.关键常量与变量根据引用[5]，默认初始容量为16（`DEFAULT_INITIAL_CAPACITY=1<<4`），最大容量为2^30（`MAXIMUM_CAPACITY=1<<30`）。默认负载因子为0.75（`DEFAULT_LOAD_FACTOR`），当链表长度大于8（`TREEIFY_THRESHOLD`）且数组长度大于64（`MIN_TREEIFY_CAPACITY`）时，链表转为红黑树；当树节点数小于6（`UNTREEIFY_THRESHOLD`）时，红黑树退化为链表。###2.哈希函数在JDK1.8中，哈希函数做了优化，将键的hashCode的高16位与低16位进行异或运算，以减少碰撞：```javastaticfinalinthash(Objectkey){inth;return(key==null)?0:(h=key.hashCode())^(h>>>16);}```然后通过`(n-1)&hash`计算索引（n为数组长度）。###3.put方法流程引用[1]和[3]提到了put方法。put方法的主要步骤：1.计算键的哈希值，确定桶索引2.如果该桶为空，则直接插入新节点3.如果该桶不为空，则遍历链表或红黑树：-若找到相同键（hash相同且equals为true），则更新值-若未找到，则在链表或红黑树中插入新节点4.插入后，如果链表长度超过阈值，则判断是否树化5.检查是否需要扩容###4.扩容机制当元素数量超过阈值（容量*负载因子）时，进行扩容。扩容时，数组大小变为原来的2倍，并重新计算每个节点的位置。在JDK1.8中，重新计算位置时，节点要么在原位置，要么在原位置+旧容量的位置，这取决于节点哈希值新增的bit位是0还是1（因为容量是2的幂，所以扩容后索引变化只需看高位）。###5.树化与反树化树化条件：链表长度大于8且数组长度大于64（否则只扩容）。反树化条件：在扩容或删除节点时，如果树节点数小于等于6，则退化为链表。###示例代码分析引用[2]提供了一个测试代码，展示了HashMap的插入和遍历。注意，遍历时由于HashMap无序，输出顺序与插入顺序可能不同。下面我们详细分析put方法的源码（简化版）：```javapublicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node<K,V>[]tab;Node<K,V>p;intn,i;//1.如果数组为空，则初始化（resize方法负责初始化或扩容）if((tab=table)==null||(n=tab.length)==0)n=(tab=resize()).length;//2.计算索引i，如果该位置为空，则直接放入新节点if((p=tab[i=(n-1)&hash])==null)tab[i]=newNode(hash,key,value,null);else{Node<K,V>e;Kk;//3.如果该位置的节点与待插入节点的hash和key相同，则记录这个节点（后面更新值）if(p.hash==hash&&((k=p.key)==key||(key!=null&&key.equals(k))))e=p;//4.如果该节点是树节点，则调用红黑树的插入方法elseif(pinstanceofTreeNode)e=((TreeNode<K,V>)p).putTreeVal(this,tab,hash,key,value);//5.否则，遍历链表else{for(intbinCount=0;;++binCount){if((e=p.next)==null){//5.1到达链表尾部，插入新节点p.next=newNode(hash,key,value,null);//5.2如果链表长度达到树化阈值，则尝试树化if(binCount>=TREEIFY_THRESHOLD-1)//-1for1sttreeifyBin(tab,hash);break;}//5.3如果找到相同键，则跳出循环if(e.hash==hash&&((k=e.key)==key||(key!=null&&key.equals(k))))break;p=e;}}//6.如果存在相同键，则更新值并返回旧值if(e!=null){VoldValue=e.value;if(!onlyIfAbsent||oldValue==null)e.value=value;afterNodeAccess(e);returnoldValue;}}//7.修改次数增加，检查是否需要扩容++modCount;if(++size>threshold)resize();afterNodeInsertion(evict);returnnull;}```###总结JDK1.8的HashMap通过数组+链表+红黑树的结构，在哈希冲突严重时仍能保持高效的查询性能。其核心在于哈希函数的设计、动态扩容以及链表与红黑树之间的转换机制。§§相关问题§§1.JDK1.8中HashMap的扩容过程是怎样的？2.为什么树化阈值设置为8？反树化阈值设置为6？3.HashMap在并发环境下会出现什么问题？4.HashMap的负载因子为什么默认是0.75？5.如何设计一个自定义对象作为HashMap的键？</think>### JDK 1.8 HashMap 实现原理分析 HashMap 在 JDK 1.8 中基于**数组 + 链表 + 红黑树**实现，核心目标是高效处理哈希冲突并优化查询性能。以下是关键实现原理： --- #### 1. **底层数据结构** - **数组（桶）**：主体结构，默认初始容量 $16$（必须是 $2^n$）[^5] ```java static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16 ``` - **链表**：解决哈希冲突（不同 key 哈希到同一数组索引） - **红黑树**：当链表长度 $>8$ 且数组长度 $≥64$ 时，链表转为红黑树（查询效率从 $O(n)$ 提升到 $O(\log n)$）[^3] --- #### 2. **哈希函数设计** 通过扰动函数减少哈希碰撞： ```java static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } ``` - **高位异或**：将 hashCode 的高 16 位与低 16 位异或，使低位更随机 - **索引计算**：`(数组长度 - 1) & hash` → 定位桶位置 --- #### 3. **PUT 方法流程**[^1] 1. **计算哈希值**：`hash(key)` 2. **定位桶位置**：`index = (n - 1) & hash` 3. **处理冲突**： - **桶为空**：直接插入新节点 `Node<K,V>` - **桶为链表**：遍历链表，若 key 存在则更新值；否则尾部插入 - **桶为红黑树**：调用树节点插入方法 `putTreeVal` 4. **树化检查**：链表长度 $>8$ 且数组长度 $≥64$ 时，转为红黑树 5. **扩容检查**：若元素总数 $>$ 阈值（容量 $\times$ 负载因子 $0.75$），触发扩容 --- #### 4. **扩容机制（Resize）** - **扩容条件**：元素数量 $>$ 容量 $\times 0.75$ - **扩容操作**： - 新容量 = 旧容量 $\times 2$（保持 $2^n$） - 重新计算所有元素位置：节点在新数组的位置 = **原位置** 或 **原位置 + 旧容量** - 红黑树可能退化为链表（节点数 $≤6$ 时） --- #### 5. **红黑树优化** - **树化条件**： - 链表长度 $>8$（`TREEIFY_THRESHOLD`） - 数组长度 $≥64$（`MIN_TREEIFY_CAPACITY`）[^3] - **退化条件**：红黑树节点数 $≤6$（`UNTREEIFY_THRESHOLD`） --- #### 6. **关键特性** - **允许 null 键/值**：`null` 键固定存储在索引 $0$ 的桶 - **非线程安全**：并发修改可能导致死循环或数据丢失 - **无序存储**：迭代顺序不保证与插入顺序一致（参考测试代码[^2]） --- ### 总结 JDK 1.8 的 HashMap 通过**数组 + 链表 + 红黑树**的混合结构，结合**动态扩容**和**智能树化**机制，在哈希冲突处理与查询效率之间取得平衡。其设计核心在于： - 扰动函数降低碰撞概率 - 红黑树优化极端冲突场景 - $2^n$ 容量设计加速索引计算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值