让星星⭐月亮告诉你,HashMap之往红黑树添加元素-putTreeVal方法源码解读

简介: 本文详细解析了Java `HashMap` 中 `putTreeVal` 方法的源码,该方法用于在红黑树中添加元素。当数组索引位置已存在红黑树类型的元素时,会调用此方法。具体步骤包括:从根节点开始遍历红黑树,找到合适位置插入新元素,调整节点指针,保持红黑树平衡,并确保根节点是链表头节点。通过源码解析,帮助读者深入理解 `HashMap` 的内部实现机制。

PS:由于文档是我在本地编写好之后再复制过来的,有些文本格式没能完整的体现,故提供下述图片,供大家阅览,以便有更好的阅读体验:
image.png
image.png

HashMap之往红黑树添加元素-putTreeVal方法源码解读

1、当要put的元素所在数组索引位置已存在元素,且是红黑树类型时,就会调用putTreeVal方法添加元素到红黑树上,具体操作步骤如下:

  1. 从根节点开始,到左右子树,层层递进,遍历红黑树,找到用于存放元素的合适位置;
  2. 将元素放入指定位置,并修改链表/红黑树相关节点的前prev后next父parent子(left/right)指向;
  3. 平衡红黑树;
  4. 保证红黑树根节点是链表头节点

    2、具体,详见下述的源码解析:

1、/HashMap中调用putTreeVal ()方法的地方/

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,  boolean evict) {
   
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
   
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            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);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            **if (e != null) {
    // existing mapping for key,会与putTreeVal方法对应
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }**
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

2、/*HashMap的putTreeVal ()方法/

/*** Tree version of putVal. */
        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v) {
   
            Class<?> kc = null;
            boolean searched = false;
            TreeNode<K,V> root = (parent != null) ? root() : this;
            for (TreeNode<K,V> p = root; ; ) {
   //从根节点开始遍历
                int dir, ph; K pk;
                if ((ph = p.hash) > h) //h小于p,hash,dir=-1<0
                    dir = -1;
                else if (ph < h) //h大于p.hash,dir=1>0
                    dir = 1;
                else if ((pk = p.key) == k || (k != null && k.equals(pk))) //走到此处说明要put的元素的k的hash和k都跟p的hash和p的k相等,说明该关键字对应元素已经在map中存在过,位置就是p的位置,直接返回该元素,进入到putVal方法的// existing mapping for key处进行处理(将元素对应的旧值替换成要put的新值v)
                    return p;
//走到此处,说明:hash相等,k不等,需要继续确定位置(到左右子树中去寻找)
                else if ((kc == null && (kc = comparableClassFor(k)) == null) || //k是不可比较类型
                         (dir = compareComparables(kc, k, pk)) == 0) {
    //k和pk无法比较,或者可以比较但比较后为0相等(这里相等但是k本身又不相等,逻辑上讲不通,说明也还是没法比较;只能再去左右分支找一下看有没有相等k的元素)
                    if (!searched) {
   
                        TreeNode<K,V> q, ch;
                        searched = true;
                        if (((ch = p.left) != null && (q = ch.find(h, k, kc)) != null) || //去左分支找
                          ((ch = p.right) != null && (q = ch.find(h, k, kc)) != null)) //去右分支找
                            return q; //找到相同k的元素则返回
                    }
                    dir = tieBreakOrder(k, pk); //找不到说明没有相同k的元素,则直接用k和ok调用System. identityHashCode(Object x)进行终极PK
                }
//疑问:为何最后一个else if里只判断不可比较的情况(还包含可比较但比较后为0,逻辑上讲不通的情况),可比较的情况为什么不判断了呢?
(猜测(不一定准确,欢迎指正):若k和pk可比较(结合上下文理解,这里可比较隐含的意思其实是两者肯定不等),则根据两者计算得到的hash值h和ph应该可以判断出大小,就不需要走到最后一个else if里了。相当于前面已经处理过可比较的情况了,包含了可比较的情形。)
//截至到现在。经过上述处理,肯定可以确定dir的值了
                TreeNode<K,V> xp = p; //这里将p原有的值存入xp,以备后续代码使用 
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
   //判断dir所指向的方向上的左右分支是否有元素,若没有,则将新元素放到指定分支(确定了新元素要存放的位置在p之后);若有元素,则继续往指定分支上循环递进处理下去
                    Node<K,V> xpn = xp.next; //因新元素位置在p之后,故要将x放入xp和xpn中间
                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn); //定义新元素,为xp=p的下一个next节点
                    if (dir <= 0) //小于等于0左节点
                        xp.left = x;
                    else//大于0右节点
                        xp.right = x;
                    xp.next = x; //x是xp的next节点
                    x.parent = x.prev = xp; //xp是x的parent父节点和prev前一个节点
                    if (xpn != null)
                        ((TreeNode<K,V>)xpn).prev = x; //将x放在xpn的前一个节点
                    moveRootToFront(tab, balanceInsertion(root, x)); //确保插入x后红黑树自平衡以及确保根节点是头节点
                    return null; //返回null,说明是新加入的k对应的元素
                }
            }
        }
目录
相关文章
|
2月前
|
存储
让星星⭐月亮告诉你,HashMap的put方法源码解析及其中两种会触发扩容的场景(足够详尽,有问题欢迎指正~)
`HashMap`的`put`方法通过调用`putVal`实现,主要涉及两个场景下的扩容操作:1. 初始化时,链表数组的初始容量设为16,阈值设为12;2. 当存储的元素个数超过阈值时,链表数组的容量和阈值均翻倍。`putVal`方法处理键值对的插入,包括链表和红黑树的转换,确保高效的数据存取。
59 5
|
2月前
|
算法 索引
让星星⭐月亮告诉你,HashMap的resize()即扩容方法源码解读(已重新完善,如有不足之处,欢迎指正~)
`HashMap`的`resize()`方法主要用于数组扩容,包括初始化或加倍数组容量。该方法首先计算新的数组容量和扩容阈值,然后创建新数组。接着,旧数组中的数据根据`(e.hash & oldCap)`是否等于0被重新分配到新数组中,分为低位区和高位区两个链表,确保数据迁移时的正确性和高效性。
67 3
|
2月前
|
机器学习/深度学习 算法
让星星⭐月亮告诉你,HashMap之tableSizeFor(int cap)方法原理详解(分2的n次幂和非2的n次幂两种情况讨论)
`HashMap` 的 `tableSizeFor(int cap)` 方法用于计算一个大于或等于给定容量 `cap` 的最小的 2 的幂次方值。该方法通过一系列的无符号右移和按位或运算,逐步将二进制数的高位全部置为 1,最后加 1 得到所需的 2 的幂次方值。具体步骤包括: 1. 将 `cap` 减 1,确保已经是 2 的幂次方的值直接返回。 2. 通过多次无符号右移和按位或运算,将最高位 1 后面的所有位都置为 1。 3. 最终加 1,确保返回值为 2 的幂次方。 该方法保证了 `HashMap` 的数组容量始终是 2 的幂次方,从而优化了哈希表的性能。
34 1
|
7月前
|
存储 算法 Java
【深入挖掘Java技术】「源码原理体系」盲点问题解析之HashMap工作原理全揭秘(下)
在阅读了上篇文章《【深入挖掘Java技术】「源码原理体系」盲点问题解析之HashMap工作原理全揭秘(上)》之后,相信您对HashMap的基本原理和基础结构已经有了初步的认识。接下来,我们将进一步深入探索HashMap的源码,揭示其深层次的技术细节。通过这次解析,您将更深入地理解HashMap的工作原理,掌握其核心实现。
63 0
【深入挖掘Java技术】「源码原理体系」盲点问题解析之HashMap工作原理全揭秘(下)
|
2月前
|
Java
让星星⭐月亮告诉你,HashMap中保证红黑树根节点一定是对应链表头节点moveRootToFront()方法源码解读
当红黑树的根节点不是其对应链表的头节点时,通过调整指针的方式将其移动至链表头部。具体步骤包括:从链表中移除根节点,更新根节点及其前后节点的指针,确保根节点成为新的头节点,并保持链表结构的完整性。此过程在Java的`HashMap$TreeNode.moveRootToFront()`方法中实现,确保了高效的数据访问与管理。
30 2
|
2月前
|
算法 Java 容器
Map - HashSet & HashMap 源码解析
Map - HashSet & HashMap 源码解析
57 0
|
7月前
|
存储 安全 Java
HashMap源码全面解析
HashMap源码全面解析
|
2月前
|
Java 索引
让星星⭐月亮告诉你,HashMap中红黑树TreeNode的split方法源码解读
本文详细解析了Java中`HashMap`的`TreeNode`类的`split`方法,该方法主要用于在`HashMap`扩容时将红黑树节点从旧数组迁移到新数组,并根据`(e.hash & oldCap)`的结果将节点分为低位和高位两个子树。低位子树如果元素数少于等于6,则进行去树化操作;若多于6且高位子树非空,则进行树化操作,确保数据结构的高效性。文中还介绍了`untreeify`和`replacementNode`方法,分别用于将红黑树节点转换为普通链表节点。
27 2
|
2月前
|
存储 Java
HashMap之链表转红黑树(树化 )-treefyBin方法源码解读(所有涉及到的方法均有详细解读,欢迎指正)
本文详细解析了Java HashMap中链表转红黑树的机制,包括树化条件(链表长度达8且数组长度≥64)及转换流程,确保高效处理大量数据。
100 1
|
2月前
|
存储 缓存 Java
HashMap源码解析
HashMap源码解析