HashMap源码阅读——红黑树

原创已于 2024-08-20 13:12:07 修改 · 694 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#源码 #hashmap #红黑树

于 2018-04-15 15:17:39 首次发布

源码专栏收录该内容

7 篇文章

订阅专栏

本文解析了Java 1.8中HashMap如何利用红黑树提高性能。关键参数包括树化阈值、链表还原阈值及最小树形化容量。通过treeifyBin方法实现链表到红黑树的转换。

HashMap源码阅读——红黑树

上节我们提到了jdk1.8中引入了红黑树来解决一个桶下链表过长的问题。

关键参数

HashMap中有三个关于红黑树的关键参数

//一个桶的树化阈值
//当桶中元素个数超过这个值时，需要使用红黑树节点替换链表节点
//这个值必须为 8，要不然频繁转换效率也不高
static final int TREEIFY_THRESHOLD = 8;
//一个树的链表还原阈值
//当扩容时，桶中元素个数小于这个值，就会把树形的桶元素 还原（切分）为链表结构
//这个值应该比上面那个小，至少为 6，避免频繁转换
static final int UNTREEIFY_THRESHOLD = 6;
//哈希表的最小树形化容量
//当哈希表中的容量大于这个值时，表中的桶才能进行树形化
//否则桶内元素太多时会扩容，而不是树形化
//为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;

红黑树定义

红黑树的每个节点的颜色非红即黑
根节点是黑色的
空叶子节点是黑色的
如果一个节点是红色的，那么它的子节点必须是黑色的
从任意节点都该节点的子孙节点的所有路径上包含相同数目的黑点树

 static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
}

红黑树保证了一种平衡，插入、删除、查找的最坏时间复杂度都为 O(logn)

treeifyBin

HashMap中树形化最重要的一个方法treeifyBin() 即树形化。在一个桶中的元素个数超过 TREEIFY_THRESHOLD(默认是8)，就使用红黑树来替换链表。

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //如果hash表为空或者hash表的容量小于MIN_TREEIFY_CAPACITY（64），那么就去新建或者扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                //新建一个树形节点，内容和当前链表节点一致
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;   //头节点
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            //之前得到的只是一个链表状的二叉树，下一步格式化红黑树
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
        return new TreeNode<>(p.hash, p.key, p.value, next);
    }

红黑树的具体格式化过程

final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;
   for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (root == null) {   //根节点
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = root;;) {  //遍历已经生成的红黑树
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)//这里的hash是经过扰动函数之后得到的hash
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&     //hash一样且（key值不可比较或者两者key值相等）
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);

                        TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root); //把根节点放到桶中
}