HashMap/ConcurrentHashMap/头插法/尾插法

最新推荐文章于 2024-09-18 19:35:40 发布
最新推荐文章于 2024-09-18 19:35:40 发布
阅读量2.4k 收藏 12
点赞数
文章标签： 链表 数据结构 hash hashmap 头插法
我是栈江湖，如果你喜欢此文章，不要忘记关注+点赞哦！你的支持是我创作的动力。如果你有任何意见或建议，欢迎在下方留言。若转载，请注明文章来源。
本文链接：https://blog.youkuaiyun.com/citywu123/article/details/127674826
版权

1.1 HashMap

JDK1.7

JDK1.8

存储

数组+链表

数组+链表+红黑树

位置算法

h & (length-1)

h & (length-1)

链表超过8

链表

红黑对(链表超过8且数组长度超64)

节点结构

Entry<K,V> implements Map.Entry<K,V>

Node<K,V> implements Map.Entry<K,V>

插法

头插法(扩容环化造成死循环)

尾插法

JDK1.7

使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，如果hashcode取模后的结果相同，那么这些key会被定位到Entry数组的同一个格子里，这些key会形成一个链表；这样数据遍历时间就过长。1.7中hashmap链表插入的方式是使用头插法。

JDK1.8

使用一个Node数组来存储数据，但是这个Node可能是链表结构，也可能是红黑树结构；如果插入的元素key的hashcode值相同，那么这些key也会被定位到Node数组的同一个格子里，如果不超过8个使用链表存储，超过8个且Node数组长度超过64，会将链表转换为红黑树。1.8中hashmap链表插入的方式是使用尾插法。

【相关问题】

问题一：为什么jdk1.8后改为尾插法？

主要是因为头插法在多线程扩容情况下会引起链表环。那什么是链表环呢？

引用一张图片(来源hashmap的头插法和尾插法_HashMap 链表插入方式 → 头插为何改成尾插 ?_邹振东的博客-优快云博客)：

1.2 ConcurrentHashMap

主要是支持安全的多线程的读写

JDK1.7

JDK1.8

实现

segment+hashentry

Node+CAS+Synchronized

锁

Segment继承ReetrantLock

Synchronized

存储

数组+链表

数组+链表+红黑树

链表超过8

数组

红黑树

插法

头插法

尾插法

 

第八篇：链表的学习：链表的头插法和尾插法以及HashMap中链表结点的插入方式
码农飞哥
01-31 2925
前言 从前面的HashMap和ConcurrentHashMap的源码分析我们可以得知，其内部的数据结构都用到了链表，所以，对链表的深入掌握非常有必要。本文将重点介绍单链表数据结构，然后通过代码实现单链表的头插法和尾插法。 单链表的介绍 我们都知道数组是需要一块连续的内存空间来存储的，而链表只需要零散的内存碎片，通过指针相连即可。首先我们来看看最简单的链表-----单链表。 如上图所示，分别是一...
HashMap和ConcurrentHashMap的扩容过程详解
felix
06-04 1954
1. HashMap的扩容过程 首先判断扩容，插入数据后，如果容量大于threshold（容量*负载因子），则进行扩容； 获取当前容量，若当前容量大于0，并且大于MAXIMUM_CAPACITY = 1 << 30，则不进行扩容，将 threshold = Integer.MAX_VALUE进行赋值。 否则创建新的数组，将容量进行两倍扩大，threshold也进行两倍扩容,下面截取部分源码； if (oldCap > 0) { if (oldCap
单链表头插法和尾插法的算法程序
01-19
头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时，记录的不是点而是边，对于每一个点所对应的邻接表都是以栈的形式存储的，也就是说先添加的边在遍历时后取出，除此以外，所有的边用一个结构体数组存储起来，每条边对应的索引就是其编号，在建立邻接表时，表中存放的实质是边的编号，在遍历时先获得编号，在放回结构体数组中获得相应的边的数据。
知识点（4）——HashMap中插入数据用的头插法还是尾插法
热门推荐
u010257931的博客
11-19 1万+
前言 大家都知道，HashMap用到的数据结构，在JDK8之前是数组+单链表。在JDK8用的是数组+单链表+红黑树。 这里说一句题外话，为什么JDK8时候引入了红黑树？ （1）因为当数组中每个元素，都是一个Entry，每一个Entry是一个单链表。 （2）当链表长度过长的时候，查询链表中的一个元素就比较耗时，这时就引入了红黑树。 （3）首先红黑树是一棵二叉树，而且属于二叉树中比较特殊的二...
Java基础面试题(下)
小猪呀的博客
09-16 1170
1.Collection下的常用子类集合有那一些？ 有List，Set。 List：有序(按添加顺序显示)，可重复，set：无序(按大小排序显示)，不可重复，map：以键值对方式存储 List分别有： ArrayList：是List的主要实现类，ArrayList的底层是数组。线程不安全的。查找快，增删慢(通过首地址+下标获取元素位置，增删要移动某一些元素)” LinkedList：底层是一个双向链表(是一个带头/尾指针的双向链表，)。插入，删除快（增删快因为直接就在对应的位置设置新的元素指向前后
hashmap头插法和尾插法区别_一个跟面试官扯皮半个小时的HashMap（看这一篇就足够了）
Hanko的专栏
12-24 3807
前言 HashMap 应该算是 Java 后端工程师面试的必问题，因为其中的知识点太多，很适合用来考察面试者的 Java 基础。 开场 面试官: 你先自我介绍一下吧！ 安琪拉: 我是安琪拉，草丛三婊之一，最强中单（钟馗不服）！哦，不对，串场了，我是**，目前在–公司做–系统开发。 面试官: 看你简历上写熟悉 Java 集合，HashMap 用过的吧？ 安琪拉: 用过的。(还是熟悉的味道) 面试官: 那你跟我讲讲 HashMap 的内部数据结构？ 安琪拉: 目前我用的是 JDK1.8 版本的，内部使用数组 +
什么是HashMap（1）
Eric的博客
10-20 839
转载自：微信公众号：程序员小灰 众所周知，HashMap是一个用于存储Key-Value键值对的集合，每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个数组当中，这个数组就是HashMap的主干。 HashMap数组每一个元素的初始值都是Null。 对于HashMap，我们最常使用的是两个方法：Get和Put。 1.Put方法的原理 调用Put方法的时候发生了什么呢？ ...
hashmap的头插法和尾插法_《进大厂系列》系列-HashMap
weixin_32903229的博客
01-02 3091
你知道的越多，你不知道的越多 点赞再看，养成习正文 一个婀娜多姿，穿着衬衣的小姐姐，拿着一个精致的小笔记本，径直走过来坐在我的面前。 看着眼前这个美丽的女人，心想这不会就是Java基础系列的面试官吧，真香。 不过看样子这么年轻应该问不出什么深度的吧，嘻嘻。（哦？是么 ） 小伙子，听前面的面试官说了，你Redis和消息队列都回答得不错，看来还是有点东西。美丽迷人的面试官您好，您见笑了，全靠看了敖...
HashMap面试题 头插法、尾插法、hash冲突、数组扩容、ConcurrentHashMap
自救 唯有自强
02-24 1165
文章目录HashMap 的数据结构？HashMap 的工作原理？HashMap 的 table 的容量如何确定？loadFactor 是什么？该容量如何变化？这种变化会带来什么问题？数组扩容的过程？说说你对红黑树的见解？jdk8中对HashMap做了哪些改变？HashMap & ConcurrentHashMap 的区别？为什么 ConcurrentHashMap 比 HashTable 效率要高？ 又到了春招季，是时候背面经，准备冲大厂啦！ 本次总结了一系列java面试中热点问题 HashMap
面试题：HashMap & ConcurrentHashMap
Elson的博客
10-25 643
关于 HashMap 和 ConcurrentHashMap 的面试题。
HashMap 链表插入方式 → 头插为何改成尾插 ?
十指波课堂的博客
12-23 3709
数据结构　　对 HashMap 的底层数据结构，相信大家都有所了解，不同的版本，底层数据结构会有所不同　　1.7 的底层数据结构/** * An empty table instance to share when the table is not inflated. */ static final Entry<?,?>[] EMPTY_TABLE = {}; /** * Th...
为什么使用HashMap需要重写hashcode和equals方法_《进大厂系列》系列-HashMap
weixin_39609483的博客
11-20 361
你知道的越多，你不知道的越多 点赞再看，养成习正文 一个婀娜多姿，穿着衬衣的小姐姐，拿着一个精致的小笔记本，径直走过来坐在我的面前。 看着眼前这个美丽的女人，心想这不会就是Java基础系列的面试官吧，真香。 不过看样子这么年轻应该问不出什么深度的吧，嘻嘻。（哦？是么 ） 小伙子，听前面的面试官说了，你Redis和消息队列都回答得不错，看来还是有点东西。美丽迷人的面试官您好，您见笑了，全靠看了敖...
HashMap扩容机制，头插法和尾插法图解
qq_50801874的博客
09-18 2179
HashMap的死循环只发生在JDK1.7版本中主要原因：头插法+链表+多线程并发+扩容，累加到一起就会形成死循环多线程下：建议采用ConcurrentHashMap替代JDK1.8，HashMap改用尾插法，解决了链表死循环问题，但是可能会数据覆盖。
JDK1.8之前，HashMap#get操作死循环问题剖析
疯狂的蜗牛
12-23 3314
JDK1.8之前，HashMap#get操作死循环问题剖析写在前面问题原因1、头插法：2、在并发环境下使用非线程安全的类具体成环的情况分析问题答疑 写在前面 1、HashMap本身是线程不安全的（不管哪个jdk版本），所以请不要在并发访问的场景下直接使用HashMap。 2、如果在并发访问的场景下，建议采用concurrentHashMap。 问题原因 1、头插法： 我们知道，在jdk1.8之前，hashMap的put操作，或扩容操作，针对hash冲突时采用的是拉链法（将冲突的对象以链表的形式串联起来），新
关于hashmap头插法和尾插法的理解
m0_49908016的博客
09-06 7046
头插法的初衷是设计者遵循一个新加进来的元素可能被使用的频率更高，这其实是一个伪命题，因为在hashmap扩容的时候，链表也是会发生颠倒的，因为是先从头节点开始转移掉新的hash表中。 头插法还有一个致命的缺点，就是在多线程下会出现循环链的情况，导致死循环 具体是怎么死循环的可以理解为因为扩容是会有一个颠倒的机制，所以多线程操作的时候有可能出现线程1让A->B 而线程2让B->A,导致了循环， jdk1.8之后改为尾插法 自己的理解，希望指正 ...
hashmap为什么用红黑树_「最完整系列」JAVA-容器篇-HashMap面试最详解
weixin_39728909的博客
11-29 355
前言在讲技术前有必要讲一下这篇文章的由来。写java的朋友，无论是客户端还是服务端，HashMap基本上都最常用的java容器了，正因为最常用，所以我们需要去了解的更深，对代码优化和规范都有好处。网上关于 hashmap 的讲解也铺天盖地多的是，那为什么我还要写一篇这个呢。原因主要在于你可以看网上任何的一篇讲 hashmap 的文章，远远没有这篇文章带给你的清晰和完整，甚至可以让你靠近人家在开发 ...
链表的学习：链表的头插法和尾插法以及HashMap中链表结点的插入方式
weixin_43740011的博客
05-30 1572
这是因为HashMap中的链表是按照插入顺序排序的，最近插入的元素会放在链表的头部，最先插入的元素会放在链表的尾部。除了链表的基本操作之外，还有一些高级的链表技巧，比如双向链表、循环链表等。循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成一个循环。在链表中，删除节点的操作也很重要，因为如果链表中的某个节点不再使用，我们需要将其从链表中删除，以免占用空间。删除一个节点的操作需要找到该节点的前一个节点，然后将前一个节点的指针指向该节点的下一个节点即可。链表的插入操作是链表中最常见的操作之一。
网易面试：JDK1.8将HashMap 头插法 改 尾插法，为何？
架构师尼恩
03-08 4030
ＨashMap是Java中的一种基于哈希表实现的，它允许我们使用键值对的形式来存储和获取数据。从根本上来说，一个哈希表包含一个数组，但是元素访问不是通过 index 编号的形式（比如 array[i]的形式），而是通过特殊的关键码(也就是key)来访问数组中的元素。存放Value的时候，通过一个哈希函数，通过 **关键码（key）**进行哈希运算得到哈希值，然后得到映射到(map到)的位置， 去存放值 ，读取Value的时候，也是通过同一个哈希函数。
hashmap头插法和尾插法区别_HashMap扩容死循环问题
weixin_26516551的博客
12-04 3344
JDK 1.7 HashMap 扩容核心算法下面这是JDK 1.7中HashMap扩容时调用的核心代码，作用是将原hash桶中的节点转移到新的hash桶中：void transfer(Entry[] newTable) {Entry[] src = table;int newCapacity = newTable.length;for (int j = 0; j < src.length; ...
hashmap头插法变成尾插法
最新发布
04-25
<think>好的，我现在要解决的问题是，如何将Java HashMap的头插法修改为尾插法。用户提到了JDK1.8已经做了这样的改动，但可能他想了解具体的实现方式或者自己尝试修改。首先，我需要回顾HashMap在JDK1.7和1.8中的不同实现，尤其是链表插入方式的变化。 根据提供的引用，JDK1.7使用头插法，而1.8改为了尾插法，主要是为了解决并发环境下的死循环问题。用户现在想了解如何手动修改头插法为尾插法，可能是在旧版本的代码中进行调整，或者理解其实现机制。 首先，我需要明确头插法和尾插法的区别。头插法是将新节点插入链表的头部，而尾插法则是插入尾部。在JDK1.7中，当发生哈希冲突时，新元素会被放在链表的头部，这可能导致在并发扩容时形成环形链表，进而导致死循环。而尾插法则避免了这个问题，同时可能提高查询效率，因为保持了插入顺序。 接下来，我需要查找HashMap源码中关于插入链表的部分。在JDK1.7中，添加元素的方法在addEntry和createEntry中，例如： void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<>(hash, key, value, e); // ... } 这里，新Entry的构造函数将下一个节点指向原来的e，即链表头部插入。如果要改为尾插法，需要遍历到链表尾部，然后将新节点添加到末尾。 但这样每次插入都需要遍历链表，时间复杂度从O(1)变为O(n)，显然会影响性能。然而，JDK1.8中使用了红黑树优化，当链表长度超过阈值时转换为红黑树，这样即使使用尾插法，也不会显著降低性能。但用户的问题可能集中在链表部分，不考虑红黑树的情况。 因此，修改头插法为尾插法的关键在于，找到插入位置为链表尾部。这需要修改插入逻辑，例如在JDK1.7的代码中，遍历链表到最后一个节点，然后将新节点添加到末尾。 但这样做的问题在于每次插入都需要遍历整个链表，这在频繁插入的场景下性能会很差。所以，可能需要在数据结构上做调整，比如维护一个尾指针，但这会增加内存开销。或者，像JDK1.8那样，在插入时记录尾节点。 另外，需要考虑扩容时的处理。在JDK1.7中，扩容时也会使用头插法转移节点，这同样需要修改为尾插法，否则扩容后的链表顺序仍然可能倒置，导致并发问题。 总结步骤可能包括： 1. 修改插入方法，将新节点添加到链表尾部。 2. 处理扩容时的节点转移，同样采用尾插法。 3. 考虑维护尾指针以优化插入效率。 4. 测试修改后的实现，确保功能正确且性能可接受。 但实际中，直接修改JDK1.7的HashMap可能并不现实，因为涉及到多处代码改动，且性能可能下降。更好的做法是升级到JDK1.8及以上版本，直接使用优化后的HashMap。但用户的问题可能更多是出于学习目的，想了解实现原理。 在思考过程中，还需要验证引用中的信息是否正确，例如JDK1.8是否真的使用尾插法，以及具体实现细节。查阅源码发现，JDK1.8的HashMap在putVal方法中，当发生哈希冲突时，会遍历链表，如果未找到相同key，则将新节点添加到链表末尾。具体代码片段： if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // ... } 这里的p是当前节点，p.next为null时，说明到了链表尾部，新节点作为p的next插入，即尾插法。 因此，在JDK1.8中，尾插法的实现是通过遍历到链表尾部，然后插入新节点。而在JDK1.7中，头插法则是直接将新节点作为头节点，替换原有链表头部。 如果要在旧版本中模拟尾插法，需要修改插入逻辑，每次找到链表尾部再插入。这需要修改对应的Entry类和插入方法，同时处理扩容时的节点转移逻辑，确保在扩容时也保持尾插法。 不过，这样的修改会显著影响插入性能，特别是在长链表中。因此，JDK1.8的改进不仅仅是尾插法，还引入了红黑树来优化长链表的查询效率，从而平衡了插入和查询的性能。 最后，用户的问题可能还涉及到并发环境下的安全性，但HashMap本身不是线程安全的，ConcurrentHashMap才是。因此，在修改头插法为尾插法时，如果目标是解决并发问题，可能需要结合其他机制，或者直接使用ConcurrentHashMap。</think>#### JDK 1.7 头插法修改为尾插法的实现原理 在 JDK 1.7 的 `HashMap` 中，链表插入采用**头插法**，即新节点直接插入链表头部。若需改为**尾插法**，需修改以下核心逻辑： 1. **链表插入逻辑调整** - **原头插法代码片段**（JDK 1.7）： ```java void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<>(hash, key, value, e); // 新节点成为链表头 // ... } ``` - **修改为尾插法**： 遍历链表至尾部，将新节点插入末尾： ```java void addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; if (e == null) { table[bucketIndex] = new Entry<>(hash, key, value, null); } else { Entry<K,V> tail = e; while (tail.next != null) { tail = tail.next; // 遍历至链表尾部 } tail.next = new Entry<>(hash, key, value, null); // 插入尾部 } // ... } ``` 2. **扩容时节点转移逻辑调整** JDK 1.7 扩容时通过 `transfer` 方法重新计算索引并转移节点，原实现仍使用头插法： ```java void transfer(Entry[] newTable) { for (Entry<K,V> e : table) { while (e != null) { Entry<K,V> next = e.next; int newIndex = e.hash & (newCapacity - 1); e.next = newTable[newIndex]; // 头插法 newTable[newIndex] = e; e = next; } } } ``` - **修改为尾插法**： 需要维护每个链表的尾指针，避免遍历： ```java void transfer(Entry[] newTable) { Entry<K,V>[] newHeads = new Entry[newTable.length]; Entry<K,V>[] newTails = new Entry[newTable.length]; for (Entry<K,V> e : table) { while (e != null) { Entry<K,V> next = e.next; int newIndex = e.hash & (newCapacity - 1); e.next = null; if (newHeads[newIndex] == null) { newHeads[newIndex] = e; newTails[newIndex] = e; } else { newTails[newIndex].next = e; // 尾插法 newTails[newIndex] = e; } e = next; } } table = newHeads; } ``` #### 性能对比与注意事项 | 方法 | 时间复杂度 | 并发安全性 | 适用场景 | |----------|------------|---------------------|------------------------| | **头插法** | $O(1)$ | 多线程下可能形成环形链表 | 单线程环境 | | **尾插法** | $O(n)$ | 避免环形链表问题 | 需手动维护尾指针或遍历 | - **缺点**：尾插法需遍历链表，时间复杂度从 $O(1)$ 变为 $O(n)$，性能显著下降[^1]。 - **优化方向**：参考 JDK 1.8 的实现，引入**红黑树**结构（链表长度 >8 时转树），平衡插入与查询效率[^1][^4]。 #### 完整代码示例（模拟 JDK 1.7 尾插法改造） ```java public class CustomHashMap<K, V> { static class Entry<K, V> { final K key; V value; Entry<K, V> next; final int hash; Entry(int hash, K key, V value, Entry<K, V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } } private Entry<K, V>[] table; private int capacity = 16; public CustomHashMap() { table = new Entry[capacity]; } public void put(K key, V value) { int hash = key.hashCode(); int index = hash & (capacity - 1); // 尾插法实现 Entry<K, V> newEntry = new Entry<>(hash, key, value, null); if (table[index] == null) { table[index] = newEntry; } else { Entry<K, V> tail = table[index]; while (tail.next != null) { tail = tail.next; } tail.next = newEntry; } } // 其他方法省略... } ``` #### 总结 JDK 1.8 的尾插法改进通过以下方式优化性能： 1. **红黑树转换**：链表长度超过阈值时转为树结构，保证 $O(\log n)$ 的查询效率[^1][^4]。 2. **哈希算法优化**：采用 `MurmurHash` 减少哈希冲突[^1]。 --相关问题-- 1. JDK 1.8 的 `HashMap` 如何通过红黑树优化链表性能？ 2. 头插法为何在并发场景下会导致死循环？ 3. `ConcurrentHashMap` 如何解决线程安全问题？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栈江湖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值