HashMap中put方法流程图

最新推荐文章于 2024-12-19 19:38:43 发布
原创 最新推荐文章于 2024-12-19 19:38:43 发布 · 1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客内容提及插入图片描述，但未给出更多关键信息。
HashMap put过程
M_Blog
08-15 626
计算索引位置的公式为：(n - 1) & hash，当 n 为 2 的 N 次方时，n - 1 为低位全是 1 的值，此时任何值跟 n - 1 进行 & 运算的结果为该值的低 N 位，达到了和取模同样的效果，实现了均匀分布。因为中间多个个7，不会使得红黑树和链表之间频繁转换，如果我们设置节点多于8个转红黑树，少于8个就马上转链表，当节点个数在8徘徊时，就会频繁进行红黑树和链表的转换，造成性能的损耗。不存在的），这个概率足够低了，并且到8个节点时，红黑树的性能优势也会开始展现出来，因此8是一个较合理的数字。.
说一下HashMap的put方法
weixin_38289612的博客
08-12 1882
文章目录前言一、HashMap是什么？二、HashMap的put方法1.HashMap中的基本属性2.put方法总结 前言 日常开发中经常使用到HashMap的put方法，本章就从HashMap的源码分析put方法的原理 提示：以下是本篇文章正文内容，下面案例可供参考 一、HashMap是什么？ 简单的理解，HashMap就是一个存放k,v键值对的容器 二、HashMap的put方法 1.HashMap中的基本属性 从源码中可以看到，继承了AbstractMap，同时实现了Map,Cloneabl..
hashma的put 方法总结
zhangqiang180的博客
07-25 2079
Hashmap put 方法流程图 HashMap的put方法流程总结 1、put(key, value)中直接调用了内部的putVal方法，并且先对key进行了hash操作； 2、putVal方法中，先检查HashMap数据结构中的索引数组表是否位空，如果是的话则进行一次resize操作； 3、以HashMap索引数组表的长度减一与key的hash值进行与运算，得出在数组中的索引，如果索引指定的位置值为空，则新建一个k-v的新节点； 4、如果不满足的3的条件，则说明索引指定的数组位置的已经存在内容，这个
HashMap的put方法
AAAWell的博客
07-20 9146
Java HashMap的put方法介绍，源码解析，深入了解HashMap的put操作流程
HashMap的put方法执行过程
qq_39492727的博客
09-07 782
hash Map 具体put过程源码解析
JDK1.8，Java，HashMap的put()方法全过程（超详细）
mfmfmfo的博客
08-24 511
7，产生Hash冲突，且和首节点不相同，且链表没有树化，那么我们需要遍历这个链表，判断键是否相同，如果键没有匹配的，就插入到链表尾部，插入后，判断长度是否超过8，超过就进行树化(里面还会对数组长度进行判断，如果没有超过64，就进行扩容)8，产生Hash冲突，且和首节点不相同，且链表没有树化，那么我们需要遍历这个链表，判断键是否相同，如果找到了匹配的键，就退出死循环，会自动执行最后面的，Key相同把Value值进行替换的代码。5，key相同则直接走线面的步骤，进行Value值的替换。使用内部类Node数组。
HashMap中put方法底层实现（JDK8）
Fyf_010316的博客
04-12 1111
1.进入put方法的实现 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 2.跳转到putVal方法 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, b...
HashMap之put详解(一)
weixin_39667787的博客
01-29 1690
文章目录1. 导读2. HashMap::put源码解析3. 红黑树的插入4. 链表转红黑树 1. 导读 这次的分享是关于HashMap::put, 主要是围绕下面几个方面展开: .1 HashMap::put源码解析; .2 红黑树插入的处理; .3 红黑树与链表的互转; 2. HashMap::put源码解析 因为HashMap::put的源码较长, 用下面的流程图来替代: 下面我们一步步来...
Hashmap——put()源码分析（JDK1.8）
qq_41614728的博客
05-17 391
HashMap的Demo： 初始化插入第一个元素： put()方法：put的第一个参数hash(key)根据key值计算hash。 hash(key)方法：当key为空，返回0；key不为空，返回h为key的hashCode值，异或h右移16位。 扰动函数：为了保证hash的散列尽量均匀。（将高位和低位进行异或操作，让高位值的不同也能对低位的值产生影响） putVal()方法： //第一放数据，创建的Node类型的数组里是空，没有对象，newNode新建一个Node对象把tab[i]放进去。 .
HashMap学习之put操作
weixin_38964103的博客
03-20 533
今天开始HashMap的学习，当然还是学源码啦~ HashMap的参数设置 走进HashMap.java首先能看到很多的参数设置，如下图： 这个16是为什么呢？ 答案：初始容量为16的原因。请戳进来！感谢大神讲解 简单总结：降低Hash碰撞的几率 负载因子是0.75是为什么呢？ 答案：也请戳进来！再次感谢讲解~ 简单来说：负载因子过大会提高空间利用率，但导致时间效率低。负载因子过小会导致空间利用率低，耗费空间。 阈值为8又是为什么呢？ 答案：又双叒来感谢！戳进来看最下面 这是一个涉及概率的问题了~~ H
HashMap的put方法流程
qq_40623646的博客
01-12 315
HashMap的put方法的具体流程？
SayBlog
08-30 7261
当我们put的时候，首先计算 key的hash值，这里调用了 hash方法，hash方法实际是让key.hashCode()与key.hashCode()>>>16进行异或操作，高16bit补0，一个数和0异或不变，所以 hash 函数大概的作用就是：高16bit不变，低16bit和高16bit做了一个异或，目的是减少碰撞。按照函数注释，因为bucket数组大小是2的幂，计算下标index = (table.length - 1) & hash，如果不做 hash 处理，相当于..
HashMap的put过程
qq_55135629的博客
08-14 938
HashMap的存储元素的过程
HashMap put详细流程图（看图秒懂）
weixin_47257050的博客
07-20 1212
HashMap put详细流程图，看完你就懂
HashMap——HashMap中的put方法
Lemon_man_的博客
05-23 2363
如果我们直接使用key.hashCode()返回哈希值的话，在进行哈希位运算时（key&(capacity-1)）时高位如果变动大的话，对哈希索引值hash的的计算结果的影响是较小的，故而产生哈希碰撞的概率就要大一点。0000 0000 0000 0000 0000 0000 0000 1111 length-1(进行位运算)0000 0000 0000 0000 0000 0000 0000 1111 length-1 进行位运算。2、根据哈希值计算出索引值hash找到哈希桶的位置。
HashMap中的put方法
wming666的博客
02-03 3764
1、put操作可以覆盖原来的value，前提条件就是hash值相同且是同一个key，或者hash值相同且两个key equals。2、插入链表后，元素大于8个，将链表转成红黑树3、元素是放在链表的尾端4、插入后，size += 1，如果size > threshold，执行扩容，5、扩容时，对链表中的键值对重新计算桶索引，方法很巧妙。原来的链表会分裂为两个新链表，一个存放索引值不变的键值对，另一个存放索引值变化的键值对；并且键值对在新链表中的相对顺序没有变；
字节一面：HashMap的put操作过程
tangjieqing的博客
12-19 886
如果一个线程正在扩容，而另一个线程也在尝试插入新元素，那么可能会出现新元素被插入到旧数组中的情况，或者新元素在迁移到新数组时丢失。：如果右移的位数过多（例如32位，这实际上相当于丢弃了整个哈希码的高位），那么哈希值将完全由低位决定，这可能导致哈希冲突的增加。：根据旧数组的大小和扩容规则（通常是扩容为原来的两倍），计算新数组的大小（newCap）和新的扩容临界值（newThr）。，并且它们计算的哈希值相同（即它们要插入的桶的下标相同），那么后一个线程可能会覆盖前一个线程插入的数据。
hashmap put原理
最新发布
10-17
<think>嗯，用户想了解HashMap的put方法的原理。结合用户给出的引用内容，我需要整理一下这方面的知识体系。 用户主要在查询HashMap中put方法的实现机制，尤其关注JDK1.8版本的特性。用户提供的引用材料涵盖了数据结构、哈希计算、冲突处理、树化机制等核心内容。 准备从数据结构开始说明，在JDK1.8中HashMap采用数组+链表/红黑树的复合结构。数组作为桶(bucket)存放链表头节点或树根节点，当链表长度超过8且数组容量达到64时会树化。这点在引用[3]中有提到树化转换条件。 哈希计算部分需要强调扰动函数的优化。JDK1.8的hash()方法将key的hashCode高16位与低16位异或，减少哈希碰撞。引用[2]提到使用hashCode()和哈希算法寻找索引，但没说明扰动细节，这点我会补充。 根据引用[3]描述的索引定位公式：(n-1)&hash，其中n是数组长度。这个位运算相当于取模但效率更高。当发生哈希冲突时，引用[2]说明会先判断节点类型：如果是树节点则调用红黑树的插入方法，否则遍历链表并考虑树化条件。 扩容机制方面着重说明引用[3]提到的优化：重新哈希时通过hash&oldCap判断元素位置。若结果为0则保持原索引，否则新位置=原索引+旧容量。这种设计避免重新计算哈希值，提升扩容效率。 最后需要强调线程安全问题。虽然不属于put原理本身，但实际应用很重要。考虑提醒用户HashMap非线程安全，多线程环境下应该用ConcurrentHashMap。 </think>好的，我们来详细解析一下 JDK 1.8 中 HashMap 的 `put(K key, V value)` 方法底层原理。整个过程围绕着**数组+链表/红黑树**的数据结构、**哈希计算**、**哈希冲突解决**以及**扩容**这几个核心概念展开： ### 核心数据结构与流程概述 1. **初始化与底层结构：** * HashMap 内部维护一个 `Node<K, V>[] table` 数组（通常称为桶数组或 bucket array）。`Node` 是存储键值对的基本单元，是一个链表节点（包含 `key`, `value`, `hash`, `next` 指针）。 * 在 JDK 1.8 中，当单个桶（数组元素）中的链表长度过长（达到阈值 8）**且**整个 `table` 数组的长度达到一定阈值（默认 64）时，该桶处的链表会转换为**红黑树（TreeNode）**，以提高极端情况下的查询效率（$O(n)$ -> $O(\log n)$）[^1][^2]。 2. **put 方法的核心步骤：** * **Step 1: 计算 Key 的哈希值 (`hash`)** * 调用 `key.hashCode()` 获取原始哈希码。 * 关键优化：HashMap 内部使用 `(h = key.hashCode()) ^ (h >>> 16)` 进行一次**扰动计算**。 * 目的：**降低哈希碰撞**。原始哈希码的高 16 位与低 16 位进行异或，使得高位的变化也能影响最终的低位结果。因为后续确定桶位置时（`(n - 1) & hash`），当 table 长度 `n` 较小时（如初始 16），实际上是只用到了 `hash` 的低几位（如 `n-1=15`，二进制 `1111`，只用了低 4 位）。扰动让高位也参与到影响低位中，让哈希分布更均匀[^1][^2]。 * **Step 2: 计算桶索引 (`index`)** * 使用公式： `index = (table.length - 1) & hash` * 解释： * `table.length - 1`：因为桶数组长度 `n` 总是 2 的幂（如 16, 32, 64...），所以 `n-1` 的二进制表示是一个低位全为 `1` 的数（如 15 -> `1111`, 31 -> `11111`）。 * `& hash`：执行按位与操作 (`&`)。这相当于对 `hash` 值进行 `取模(n)` 操作 (`hash % n`)，但效率远高于取模运算。 * 结果：`index` 的值在 `[0, table.length - 1]` 之间，确定了键值对应该放入哪个桶（数组哪个位置）[^1][^2][^3]。 * **Step 3: 处理目标桶 (`table[index]`)** * **情况 A：桶为空 (`table[index] == null`)** * 最简单的情况：直接在该索引位置创建一个新的 `Node` 节点存放键值对即可。 * **情况 B：桶不为空 (哈希碰撞发生)** * 需要遍历该桶位置的链表或红黑树，进行更新或插入： 1. **检查第一个节点：** * 比较 `table[index]` 节点的 `hash` 值和传入的 `hash` 值。 * 如果 `hash` 相等，再用 `equals()` 方法（或 `==`）比较 `key`。 * 如果 `key` 也相等：找到了**重复的 key**！用新 `value` **覆盖**旧的 `value`，返回旧 `value`。 2. **后续节点处理：** * 如果第一个节点不匹配，判断该桶结构是链表还是红黑树： * **如果是红黑树 (`TreeNode`)：** 调用红黑树的 `putTreeVal()` 方法进行查找/插入。该方法会按照红黑树的规则查找 key。如果找到相同 key 则覆盖 value，找不到则插入新节点并在必要时调整树结构以保持平衡。 * **如果是链表：** 遍历链表（`next` 指针）： * 对每个节点，重复步骤 1 的比较（`hash` 和 `key.equals()`）。 * 如果找到相同 key：覆盖 value，返回旧 value。 * 如果遍历到链表尾部 (`next == null`) 仍未找到：在链表尾部插入一个新的 `Node` 节点。 * **链表树化检查：** 插入新节点后，检查当前链表长度： * 如果插入后链表长度 **>= 8** (`TREEIFY_THRESHOLD = 8`)，则调用 `treeifyBin(tab, hash)` 尝试将该链表转换为红黑树。 * 在 `treeifyBin` 方法中，会**先检查当前 `table` 的长度**： * 如果 `table` 长度 **< 64** (`MIN_TREEIFY_CAPACITY = 64`)，则不进行树化，而是优先选择**扩容 (`resize()`)**，因为扩容本身就能分散节点，可能解决链表过长问题。 * 如果 `table` 长度 **>= 64**，则真正将该桶处的链表节点转换为 `TreeNode` 节点，并构建成一颗红黑树[^1][^2]。 * **Step 4: 修改计数与扩容检查** * 每次成功添加新节点（而非覆盖旧值）后，`size`（HashMap 中键值对总数）会加 1。 * 检查 `size` 是否超过了 `threshold`（阈值 = `capacity * loadFactor`，`capacity` 是 `table.length`，`loadFactor` 是负载因子，默认 0.75）。 * 如果 `size > threshold`：触发 **`resize()`** 扩容操作。 3. **扩容 (`resize()`) 原理：** * **目的：** 增大桶数组容量，减少哈希碰撞，为链表树化或保持性能提供空间。 * **过程：** 1. 创建一个新的 `Node` 数组，其容量是原数组容量的 **2 倍**（`newCap = oldCap << 1`）。 2. 遍历原数组的每一个桶（链表或树）。 3. 将原桶中的每个节点重新计算其在新数组中的位置（`(newCap - 1) & hash`），并将其移动到新数组对应的桶中。 * **JDK 1.8 优化：** 重新计算索引 (`index`) 时，利用了一个特性： * 因为 `newCap = oldCap * 2`（是 2 的幂），所以 `newCap - 1` 的二进制表示比 `oldCap - 1` 多一个高位 `1`（例如，16 -> 15(`1111`), 扩容到 32 -> 31(`11111`)）。 * 节点在新数组中的位置只可能是两个值之一：**原位置 `oldIndex`** 或 **原位置 + 原容量 `oldIndex + oldCap`**。 * **判断依据：** 计算 `(e.hash & oldCap)`（注意这里是 `oldCap`，不是 `oldCap-1`）： * 结果为 **0**：节点在新数组中的位置 = **原位置 (`oldIndex`)**。 * 结果**不为 0**：节点在新数组中的位置 = **原位置 + 原容量 (`oldIndex + oldCap`)**。 * **优点：** 省去了重新计算 `hash` 值的开销（`hash` 值本身不变），只需要判断一次位运算 (`hash & oldCap`) 的结果，就可以高效地将节点分配到新数组的两个桶中（要么在原桶，要么在原桶+oldCap 位置）。这个优化显著提升了扩容效率[^3]。 * 树节点在移动过程中，如果树变得太小（节点数 <= `UNTREEIFY_THRESHOLD = 6`），会被转换回链表。 ### 总结流程图 ```mermaid graph TD A[调用 putkey, value] --> B[计算 key 的 hash = key.hashCode ^ hashCode>>>16] B --> C[计算桶索引 index = n-1 & hash] C --> D{桶 table[index]为空?} D -- Yes --> E[创建新 Node 插入] D -- No --> F{桶中第一个节点 key 匹配? hash 和 equals} F -- Yes --> G[覆盖 value] F -- No --> H{桶结构是红黑树?} H -- Yes --> I[调用 putTreeVal 插入/覆盖] I -- 新节点插入? --> J[增加 size] H -- No 链表 --> K[遍历链表] K --> L{找到相同 key?} L -- Yes --> M[覆盖 value] L -- No 到尾节点 --> N[尾部插入新 Node] N --> O[增加 size] O --> P{链表长度 >= 8?} P -- Yes --> Q{table 长度 >= 64?} Q -- Yes --> R[转换链表为红黑树] Q -- No --> S[优先触发 resize 扩容] P -- No --> T[继续后续流程] E & J & R --> U[增加 size] U --> V{size > threshold?} V -- Yes --> W[触发 resize 扩容] V -- No --> X[流程结束] G & M -- 覆盖操作 --> X ``` ### 关键点回顾 1. **扰动哈希：** `(h = key.hashCode()) ^ (h >>> 16)` 提升散列均匀性。 2. **索引计算：** `index = (table.length - 1) & hash` 高效定位桶。 3. **冲突解决：** 通过链表或红黑树解决同一个桶内的哈希冲突。 4. **树化条件：** 链表长度 >= 8 **且** 数组长度 >= 64 时才树化，否则优先扩容。 5. **扩容触发：** `size > threshold` (capacity * loadFactor)。 6. **扩容优化：** 利用 `(e.hash & oldCap) == 0` 高效定位节点在新数组的位置（原位置或原位置+oldCap），避免重新计算hash。 7. **覆盖规则：** Key 相同（`hash` 相等且 `key.equals()` 为 true）时覆盖旧值。 通过以上步骤和优化，HashMap 的 `put` 方法能够在平均情况下实现高效的 $O(1)$ 时间复杂度（常数时间）的插入操作，并在冲突较多时通过链表或红黑树维持可接受的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值