HashMap 源码分析（二）

最新推荐文章于 2024-11-04 19:24:37 发布

知行小栈

最新推荐文章于 2024-11-04 19:24:37 发布

阅读量1k

点赞数 16

分类专栏： Java 集合篇文章标签：哈希算法散列表算法 java

本文链接：https://blog.csdn.net/LearnerDL/article/details/137433757

版权

Java 集合篇专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、序言

该篇为上一篇 HashMap put() 方法源码分析的填坑之作。本文将探讨在红黑树中是如何处理 put 操作的。

二、红黑树 put 处理之前发生了什么

在这里插入图片描述

上篇中，当讨论 HashMap 的 put() 方法执行到红黑树插入数据（即上图绿色部分）时，我们并没有讨论。现在我们看看此处究竟发生了什么。

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)
    // 若节点是红黑树，则将节点转换成 TreeNode，并调用 TreeNode 中的 putTreeVal 方法
    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
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    afterNodeAccess(e);
    return oldValue;
}

上面的代码为 HashMap 中 put() 方法发生 hash 冲突时的源码（在上篇中已讨论，若有疑惑详见上篇内容）。我们发现：如果判断出节点为红黑树时，首先会将节点转换成 TreeNode，并且调用 TreeNode 的 putTreeVal() 方法完成 put 操作（e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);)

三、红黑树的 putTreeVal() 方法

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)
            // 表示左子节点
            dir = -1;
        else if (ph < h)
            // 表示右子节点
            dir = 1;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        else if ((kc == null &&
                  (kc = comparableClassFor(k)) == null) ||
                 (dir = compareComparables(kc, k, pk)) == 0) {
            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;
            }
            dir = tieBreakOrder(k, pk);
        }

        TreeNode<K,V> xp = p;
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            Node<K,V> xpn = xp.next;
            TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            xp.next = x;
            x.parent = x.prev = xp;
            if (xpn != null)
                ((TreeNode<K,V>)xpn).prev = x;
            moveRootToFront(tab, balanceInsertion(root, x));
            return null;
        }
    }
}

上述代码为 putTreeVal() 方法源码。源码不够清晰，我们结合下图来分析该方法的逻辑。

在这里插入图片描述

首先，使用循环从 root（根节点）遍历红黑树
判断当前节点的哈希值是否大于插入键的哈希值
条件满足，插入方向应该为左子树（dir = -1），继续下一次循环遍历左子树
条件不满足，判断当前节点的哈希值是否小于插入键的哈希值
条件满足，插入方向应该为右子树（dir = 1），继续下一次循环遍历右子树
条件不满足，通过 == 和 equals 判断当前节点 key 与需要插入的 key 是否相等
若相等，则 key 已存在，直接返回 TreeNode，跳出循环
若不相等，则判断 key 是否可比较（即判断是否实现了如同 Comparable 这样的接口）
若 key 不可比较，则向下执行
若 key 可比较，则先判断当前节点是否已经被搜索过
若当前节点未搜索过，则继续寻找从该节点以及子节点是否已存在要 put 的 key
若 key 已存在，直接返回 key 相等的 TreeNode，跳出循环
若当前节点已被搜索过，则调用 tieBreakOrder() 方法决定节点的插入位置
流程继续向下执行
判断是否遇到了叶子节点
不是叶子节点，继续下一次循环
是叶子节点，直接插入新节点，调用 balanceInsertion() 方法保持红黑树平衡，调用 moveRootToFront() 方法将红黑树的根节点移动到最前面，跳出循环
至此，流程处理结束

四、FAQ

在 putTreeVal() 方法中我们发现：如果 key 已存在，方法是直接返回 TreeNode，并未做 value 的更新操作。这是因为在 HashMap 的 putVal() 方法中有这么一段代码：

/*
    这里的 e 就是指向 TreeNode，如果 putTreeVal() 返回了一个 TreeNode。
    那么，e != null 就成立，if 块里面的代码将会执行，使用新 value 替换旧 value
*/
if (e != null) { // existing mapping for key
    // 新 value 替换 旧 value
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    afterNodeAccess(e);
    return oldValue;
}

所以，在红黑树中执行 put 操作时也是如果 key 已存在，那么执行更新 value 的操作；若 key 不存在，那么执行新增节点的操作。

tieBreakOrder() 方法的作用是什么？

static int tieBreakOrder(Object a, Object b) {
    int d;
    if (a == null || b == null ||
        (d = a.getClass().getName().
         compareTo(b.getClass().getName())) == 0)
        d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
             -1 : 1);
    return d;
}

从上面的源码可以看出 tieBreakOrder() 方法的目的还是比较出大小（即判断 key 应该在哪个位置，只不过比较的方式采用的是类名）。所以，这个方法的作用是在 HashMap 内部的节点插入时解决哈希冲突，确保节点能够按照一定的顺序被插入到树中。

putTreeVal() 方法在最后执行了 balanceInsertion() 方法与 moveRootToFront() 方法。balanceInsertion() 方法是为了保证红黑树的平衡没什么好说的，那么为什么需要 moveRootToFront() 方法呢？moveRootToFront() 方法用于优化树的结构，将树的根节点移动到链表的最前面，这样可以提高对树结构进行遍历或查找操作时的性能。这是 HashMap 内部的一个优化策略，用于提高在树结构中进行操作时的性能。