JDK8_HashMap PUT和RESIZE操作

最新推荐文章于 2022-07-27 14:17:10 发布
最新推荐文章于 2022-07-27 14:17:10 发布
阅读量313 收藏
点赞数 1
分类专栏： java HashMap 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weianluo/article/details/112695867
版权

    现在一般面试中都会问到Jdk1.8的HashMap，里面的细节确实是魔鬼， 今天这篇文章结合源码好好分析1.8中hashmap

    本文只介绍Jdk1.8 HashMap源码较1.7 升级的其中两个部分， 分别是put和resize两个操作

 

 

1.  put操作

源码

    /**
     * Implements Map.put and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //步骤①：如果Table为空，初始化一个Table
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

        //步骤②：如果该bucket位置没值，则直接存储到该bucket位置，用&来代替%
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            
            //步骤③：如果节点key存在，直接覆盖value
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //步骤④：如果该bucket位置数据是TreeNode类型，则将新数据添加到红黑树中。
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {  //步骤⑤：如果该链为链表
                for (int binCount = 0; ; ++binCount) {
                    //添加到链表尾部
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);          //如果链表个数达到8个，且数组长度大于等于64，将链表修改为红黑树结构
                        break;
                    }
                    // key已经存在直接覆盖value
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }

            //更新键值，并返回旧值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //步骤⑥：存储的数目超过最大容量阈值，就扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

总结： put操作

1. 如果table数组为空， 初始化一个数组 （所以hashmap使用懒加载的方式）

2. p = tab[i = (n - 1) & hash]) == null， 如果这个桶还没有Node元素， 新插入一个Node

3. 如果当前桶已经存在Node， 分以下两种情况：

     a. 当前是链表

           如果当前key值节点存在，则直接更新value， 如果当前key值节点不存在，则在链表末尾插入一个新节点。 如果链表长度大于等于8，且数组长度大于等于64， 转换成红黑树（如果数组长度小于64， 直接resize）

     b. 当前是红黑树

         如果当前key值节点存在，则直接更新value，如果当前key值节点不存在，则在红黑树插入一个新的节点。

 

2. resize 操作

只列举与本文有关的关键代码

if (loTail != null) {
   loTail.next = null;
   //这里很重要，新的位置为原老所处的位置，为什么扩容之后的位置还是原数组位置呢？下面解释
   newTab[j] = loHead;
}
if (hiTail != null) {
   hiTail.next = null;
   //这里很重要，新的位置为原老所处的位置+原数组的长度，为什么是这个值呢？下面解释
   newTab[j + oldCap] = hiHead;  
}

理解上文代码需要对JDK7里面的HashMap扩容方法有一定的了解，本文就不展开了。

看不懂没关系，只需要注意newTab[j] = loHead和newTab[j + oldCap] = hiHead这两行代码，其中newTab为新的数组，j为元素在原数组中的下标，oldCap为原数组的长度，loHead和hiHead都为元素。那么这两行的代码的意思就是说：

经过rehash之后，元素的位置要么是在原位置，要么是在原位置加原数组长度的位置。

那么为什么是这样的呢？这一步，是一个非常巧妙的地方，也是本文分析的重点。

解释：为什么经过rehash之后，元素的位置要么是在原位置，要么是在原位置加原数组长度的位置？

要搞明白这个问题首先要清楚

HashMap的数组长度恒定为2的n次方，也就是说只会为16，32，64，128这种数。源码中有限制，也就是说即使你创建HashMap的时候是写的

Map<String,String> hashMap = new HashMap<>(13);

最后数组长度也会变成16，而不是你的13. 会取与你传入的数最近的一个2的n次方的数。

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

上面代码的意思是，把你所在入参cap的右边全部变成1， 然后加1， 如果传入是13，则输出16， 如果传入是16， 则输出16

那么明确这一点有什么用呢？HashMap中运算数组的位置使用的是leng-1，

那么就是对于初始长度为16的数组，扩容之后为32，对应的leng-1就是15，31，他们所对应的二进制为

15：0000 0000 0000 0000 0000 0000 0000 1111
31：0000 0000 0000 0000 0000 0000 0001 1111

n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

 

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。

以下是resize源码

        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 { // preserve order
                        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;
                        }
                    }
                }
            }
        }

我们重点看链表的resize，Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null;

代码把某一个桶的链表分成了两部分，一部分是loHead, 一部分是hiHead, loHead链表放在原来j的位置， hiHead链表放在原来位置j + oldCap的位置

红黑树部分的resize

源码如下

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }

思路也跟链表的resize一样， 分成hiHead和loHead

 

参考文档： 

1. JDK1.8 源码

2. https://tech.meituan.com/2016/06/24/java-hashmap.html

 

 

 

马各阿牛
关注
专栏目录
JDK1.8 HashMap中resize()方法解释
journey_fan的专栏
04-25 3199
JDK1.8 HashMap中resize()方法解析 * 初始化或者是将table大小加倍。如果为空，则按threshold分配空间，否则，加倍后，每个容器中的元素在新table中要么呆在原索引处，要么有一个2的次幂的位移 * @return the table */ final Node[] resize() { Node[] oldTab
java中的基于jdk1.8的hashmap的get方法、put方法和resize扩容方法源码浅析
任枫的博客
05-21 355
HashMap类成员变量释义，代码如下： static final int DEFAULT_INITIAL_CAPACITY = 16;//默认初始容量大小16 static final int MAXIMUM_CAPACITY = 1073741824;//hashmap最大容量是2的30次方 static final float DEFAULT_LOAD_FACTOR = 0.75...
HashMap的put和resize方法
GDFHGFHGFH的博客
07-12 235
最近看了hashmap的源码，在这里简单的分析一下其中put()和resize()方法 put()方法 在查看源码的时候发现put方法实际上调用了putVal这个方法 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 那么我们来看看putVal方法，代码的注释我已经写上去了，在这里我们假设创建的map是用无参构造的，没有指定负载因子和容量，所以在一开始去调用pu
HashMap的put和resize
weixin_44852871的博客
08-05 199
简介 Map集合使我们经常使用的一种集合类,我们先看看它的继承图: 它根据键的hashCode值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null，允许多条记录的值为null。HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用Concurre
Java基础——对HashMap的put和resize方法进行理解
帥樂
11-22 390
Java基础——对HashMap的put和resize方法进行理解前言一、Put方法put方法源码put方法总结：二、resize方法resize源码resize方法总结： 前言 我们可以看到，在面试所有大厂Java岗位的时候，都有对了解HashMap原理的要求， 意识到透彻了解HashMap的底层原理迫在眉睫，所以决定再写一篇博文对HashMap进行记忆和分享。 一、Put方法 开篇我们直接上干货！ put方法源码 public V put(K key, V value) { return
HashMap：put与resize
qq_52873070的博客
07-16 151
简介 HashMap 一直是面试考察的重点，在JDK1.8中，HashMap的底层进行了优化，引入了红黑树的数据结构，并且对扩容机制进行了优化。本文将讲解 HashMap中的Node，resize(),以及put方法； 继承关系 HashMap继承自接口 java.util.Map，同样继承自该接口的还有Hashtable(遗留类,且线程安全)、LinkedHashMap(HashMap的子类，可以保存插入顺序)和TreeMap(可以根据存入的的键值进行排序)。 HashMap中的关键字段 .
HashMap源码分析(一)之hash方法，put方法，resize方法
莫失莫忘的博客
07-19 696
1、什么是HashMap HashMap是基于hash表的一个Map接口的实现。也就是数组+链表的存储方式。、 数组特点：查找快 增删 慢 链表的特点： 增删快 查找慢 数组链表将两个特性结合了 哈希表、 是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列...
javahashmap源码-java_HashMap_jdk1.7:我的hashmap
05-24
例如，`resize()`方法用于扩容，`putVal()`方法实现了插入逻辑，`get()`和`remove()`方法则分别处理查找和删除操作。 通过以上分析，我们可以看到HashMap在JDK 1.7中的实现是高效且灵活的，但需要注意其非线程安全...
对比JDK8与JDK7中HashMap的差异
小超的博客
06-22 1014
不管在开发还是在面试过程中我们经常会接触到HashMap，本文就主要对HashMap存取过程以及数据结构实现原理从源码层面上进行理解。 一. HashMap的实现原理 HashMap基于hashing原理，通过put(key,value)和get(key)方法存储和获取对象。 当存储对象时，将键值对传递给put(key,value)方法时，它将调用键对象key的hashCode()方法来计算hashCode，然后找到bucket(桶)位置，来存储对象value。 当获取对象时，也是先计算key的hashC
详解HashMap的put方法在JDK 7和JDK 8的实现
qq_14825051的博客
09-27 381
文章目录JDK 71.put(K key, V value)方法**putForNullKey(value)方法****hash(key.hashCode())方法****indexFor(hash, table.length)**判断是否需要进行旧值覆盖addEntry(hash, key, value, i)方法JDK 81.put(K key, V value)方法hash(key)方法**putVal(hash(key), key, value, false, true)方法** JDK 7 1.p
jdk7中hashmap实现原理和jdk8中hashmap的改进方法总结
linyaodonga的博客
07-28 573
一. HashMap的数据结构 数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。 数组 数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难； 链表 链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。 哈希表 那么我们能不能...
HashMap 的 put、resize、get 和 remove 详细流程（Java 7 版本）
GitChat
02-12 478
HashMap 是面试官必问的基础知识点，下面老牛给您讲解 put()、resize()、get() 和 remove() 的详细流程，Let's go！ 本 Chat 你将会获得以下知识： put() 详细流程 resize() 详细流程 get() 详细流程 remove() 详细流程 适合人群： Java 面试、技术整理总结。...
Java 8 HashMap（二）—— resize（）初始化和扩容方法和get（）查找方法
炸酱面的博客
04-03 553
废话不多说直接上代码，说明都在代码注释上 final Node<K, V>[] resize() { //获得当前Map的Node数组，此步骤在于不直接对table进行修改 Node<K, V>[] oldTab = table; //获取当前Map的容量 int oldCap = (oldTab == null) ? 0 : oldTab.length; //获取当前Map扩容位置
【转】JDK8：HashMap源码解析：resize方法
tkzc_csk的博客
04-02 202
原文：https://blog.csdn.net/weixin_42340670/article/details/80503517 一、概述 HashMap的resize方法的作用：在向HashMap里put元素的时候，HashMap基于扩容规则发现需要扩容的时候会调用该方法来进行扩容。 二、方法解析 final Node<K,V>[] resize() { Node&...
HashMap底层原理 (二) put和resize方法
东岳的博客
05-27 306
HashMap的put方法 hashMap中最常用的put方法 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V
HashMap(JDK-1.8)
全力付出
04-13 350
HashMap(JDK-1.8)一：resize扩容 当前table Node数组赋给临时变量，并记录老table的初始化容量和加载因子 如果老初始化容量大于0，新表初始化容量直接扩大为原来的2倍 循环老table，对新table赋值 1) 如果如果链表只有一个，则进行直接赋值newTab[e.hash & (newCap - 1)] = e
JDK8中HashMap的resize()方法算法精髓
qq_38089964的博客
01-08 1407
向HashMap的put添加元素过量的时候，hash结构会退化成链表。所以会有一个扩容机制来解决这种问题，扩容的步骤就是新建一个大一倍的数组，将旧的数组里面的所有节点重新计算放到新的数组里面。 在jdk1.7中是重新计算节点新槽位的下标再插入，但是在1.8中是采用一种新的方式。 关键源码： for (int j = 0; j &lt; oldCap; ++j) { ...
Java源码解读（一）——HashMap的resize与put
zero4eva的专栏
06-05 719
HashMap是java面试必不可少的问题之一，这里只列出了java1.8中比较难读懂的put操作的源码，get操作的源码请自行阅读。 new 申请内存是在第一次的put操作时进行的 resize final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == ...
JDK8中HashMap底层源码解析-resize方法
qq_52173163的博客
07-27 590
上一篇文章已经解析过JDK8中HashMap的put和putVal底层源码，这篇文章顺着上一篇文章的节奏，来解析一下另外一个非常重要的方法resize方法。本章主要解析了JDK8中HashMap的resize方法的底层源码，这个方法主要有两个作用，一是用来初始化数组，二是用来扩容，而扩容的时候就需要转移元素，转移元素又分为四种情况。同时在转移红黑树的时候还提到了一个方法split()方法，在以后的文章中将会解析到。httpshttps。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值