JDK1.8HashMap的resize()方法

最新推荐文章于 2022-12-29 14:25:52 发布
转载 最新推荐文章于 2022-12-29 14:25:52 发布 · 723 阅读 · 0

本文详细探讨了HashMap的重要性和其内部实现机制。从初始化到添加元素，深入解析HashMap的每个关键步骤，帮助读者掌握这一数据结构的核心原理。

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

源码-JDK1.8HashMap扩容方法resize()解析
CodeDabaicai的博客
12-13 430
1、准备知识 HashMap的底层数据结构 Java语言的基本数据结构可以分为两种，一种是数组，另一种的模拟指针/引用，Java语言中涉及到的数据结构都是这两种的扩充。JDK1.8之前HashMap是数组+链表结合的链表散列。JDK1.8在解决哈希冲突上发生了变化，当链表长度大于阈值/默认8的时候，会将链表转化为红黑树，减少搜索时间。 hash算法 我们希望HashMap的元素位置尽量分散，最好是每个位置只有一个元素，这样用hash算法求得该位置后可以直接返回结果，不用再遍历链表/红黑树。 H
1.8HashMap源码解析之resize方法
qq_43552690的博客
04-03 927
(1) HashMap的大小总是2的n次方，这样在扩容的时候，链表中的结点只会被移动新数组的两个下标，一个就是与旧的数组下标相同的位置，另一个下标就是在旧数组的下标加上旧数组的长度，怎么判断是这两个下标的哪个呢？将hash值与旧数组的长度进行与运算，为0，则在新数组的下标与旧数组的下标相同，为1，则在新数组的下标为旧数组下标加上旧数组长度。第一步：e指针指向当前遍历到的结点，假设k1与旧数组长度与之后的结果为0，则将loHead和loTail两个指针指向k1结点，如下图所示，并向e指针下移到k2结点。
JDK1.8---HashMap的resize()扩容方法源码详解
qq_36856024的博客
08-17 4221
JDK1.8---HashMap的resize(）扩容方法源码详解resize()方法触发时机下面开始根据源码介绍HashMap的扩容原理下面进行分步分析扩容 resize()方法触发时机 首先总结一下JDK1.8的HashMap都在什么时候触发resize()方法，根据阅读源码总结了三个时机触发扩容，这里只做介绍，后面根据源码详细分析 HashMap是由数组+链表+红黑树构成的，数组就称之为桶了...
JDK1.8中HashMap的resize()方法详解
frozenpenguin的博客
12-29 1838
resize()方法的代码比较长，我们先用文字来总结一下该方法具体做了什么。首先记录当前数组信息，当前数组、数组长度还有扩容阈值。接着就到了一个if-elseif-else的代码块，这些就是用来判断当前是进行初始化操作还是扩容操作，如果是扩容操作则需要进行双倍扩容，如果是初始化数组则需要设置数组容量。如果是扩容操作或者初始化的时候用户指定了初始容量，则要⽤新数组的大小重写计算扩容阈值重新生成一个数组（无论是扩容操作还是初始化操作都需要）。
hashMap resize原理 jdk1.8
hhhhhhhhh的博客
11-12 542
jdk1.7与1.8之间的hashMap区别之一就是在于resize()方法解决了1.7多线程状态下扩容可能出现的链表死循环的问题，并取消reshash的操作，提升了运行时间。 使用idea的快捷键 CTRL+F12 打开hashMap的代码，搜索resize得到如下代码： final Node<K,V>[] resize() { Node<K,V>[] o...
JDK1.8HashMap底层实现原理
weixin_43145539的博客
05-27 4776
hashmap是我们开发中用的最常见的集合之一，但是我们是否有了解过他的底层呢？这篇文章我将带您了解一下hashmap的底层 位运算 在学习hashmap底层原理的时候，我们必须要掌握位运算，别问为什么，往下面看自然知晓 ...
jdk1.8 hashmap
02-07 447
1、HashMap概述 在JDK1.8之前，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的节点都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。 下图中代表jdk1.8之前的hashmap结构，左边部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的...
JDK1.8 HashMap扩容
Naker_的博客
03-28 1945
说在前边 JDK1.8中的HashMap较于前代有了较大的变更，主要变化在于扩容机制的改变。在JDK1.7及之前HashMap在扩容进行数组拷贝的时候采用的是头插法，因此会造成并发情景下形成环状链表造成死循环的问题。JDK1.8中改用了尾插法进行数组拷贝，修复了这个问题。同时JDK1.8开始HashMap改用数组+链表/红黑树组合的数据结构来提高查询效率，降低哈希冲突产生的链表过长导致的查询效率减缓现象。 本文的主要内容是对JDK1.8中的扩容机制与前代进行比较，分析其异同。 准备 数组大小的计算 在JDK
JDK1.8 HashMap详解
浅汐
12-08 954
HashMap是一个散列表，它存储的内容是键值对(key-value)映射。 1 定义 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { } 由HashMap定义可以看出 1） HashMap&l...
HashMap (jdk1.8)resize()方法详细注释
汉堡配大蒜
07-05 265
//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 926
HashMap1.8中resize过程，扩容后索引重排流程
JDK1.8HashMap源码解析之resize扩容操作
weixin_43608392的博客
11-08 464
一、概述 1.根据不同情况对容量以及阈值进行赋值 2.如果旧哈希表不为空，创建新哈希表准备扩容 3.遍历旧哈希表 （1）只有一个头节点的链表，将该头节点重新结算哈希放到新的哈希表 （2）红黑树 （3）遍历链表，如果扩容后的下标是否扩容前的相等， JDK1.8关于HashMap扩容时的resize()方法中(e.hash & oldCap) == 0算法讲解.将该节点放到新的哈希表，否则将下标加上扩容前容量放到新的哈希表 一、源码解析 final HashMap.Node<K,V&g
JDK1.8 HashMap 扩容 resize
kl_Dreaming的博客
09-15 349
之前一直没了解过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 449
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 270
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
深入理解HashMap底层原理剖析(JDK1.8) 扩容方法resize()
MayMatrix 的博客
05-29 1972
接下来会从以下几个方面介绍 HashMap 源码相关知识： 　　1、HashMap 存储结构 　　2、HashMap 各常量、成员变量作用 　　3、HashMap 几种构造方法 　　4、HashMap put 及其相关方法 　　5、HashMap get 及其相关方法 　　6、HashMap remove 及其相关方法 　　7、HashMap 扩容方法　resize() 　　介绍方法时会包含方法实现相关细节。 　　先来看一下 HashMap 的继承图： 　　 HashMap 根据键的
hashMap1.8 resize（）个人解读
weixin_42474495的博客
04-08 438
参考文章： 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 3290
JDK1.8 HashMap中resize()方法解析 * 初始化或者是将table大小加倍。如果为空，则按threshold分配空间，否则，加倍后，每个容器中的元素在新table中要么呆在原索引处，要么有一个2的次幂的位移 * @return the table */ final Node[] resize() { Node[] oldTab
jdk1.8 HashMap的扩容resize()方法详解
diangan2660的博客
03-27 260
/** * Initializes or doubles table size. If null, allocates in * accord with initial capacity target held in field threshold. * Otherwise, because we are using powe...
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、付费专栏及课程。

余额充值