HashMap源码深度分析(JDK1.8)

最新推荐文章于 2022-03-11 16:12:52 发布

AnEra

最新推荐文章于 2022-03-11 16:12:52 发布

阅读量302

点赞数 1

分类专栏： # JDK 文章标签： hashmap

本文链接：https://blog.csdn.net/qq_38975553/article/details/107757689

版权

JDK 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 网上关于HashMap的一些问题的错误解析

(4) 在链表长度超过8时, 链表可能会转为红黑树

(5) 最小红黑树容量: MIN_TREEIFY_CAPACITY

(6) String类型变量的hash值生成策略

1. 网上关于HashMap的一些问题的错误解析

为什么负载因子默认为 0.75?

关于负载因子的设定, 网上大部分都是粘贴出来源码中的注释:

Because TreeNodes are about twice the size of regular nodes, we
use them only when bins contain enough nodes to warrant use
(see TREEIFY_THRESHOLD). And when they become too small (due to
removal or resizing) they are converted back to plain bins. In
usages with well-distributed user hashCodes, tree bins are
rarely used. Ideally, under random hashCodes, the frequency of
nodes in bins follows a Poisson distribution
(http://en.wikipedia.org/wiki/Poisson_distribution) with a
parameter of about 0.5 on average for the default resizing
threshold of 0.75, although with a large variance because of
resizing granularity. Ignoring variance, the expected
occurrences of list size k are (exp(-0.5) pow(0.5, k) /
factorial(k)). The first values are:

0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
more: less than 1 in ten million

大概翻译如下:

因为TreeNode的大小约为链表节点的两倍，所以仅在一个链表中包含足够多的节点时才会转为红黑树（参考TREEIFY_THRESHOLD）。当它们变得太小时(由于移除或调整大小), 我们会将红黑树转为链表, 如果一个用户的数据他的hashcode值分布十分好的情况下，将会很少使用到红黑树结构。在理想情况下，使用随机hashCode值下, 负载因子为0.75,尽管由于粒度调整会产生较大的方差, key经过hash计算后进入某一个桶的概率为0.5, 即桶中的Node的分布频率服从参数为0.5的泊松分布, 预期列表大小k的出现是(exp(-0.5) * pow(0.5, k) / * factorial(k))

因为这个是在jdk1.8中HashMap上的注释, 并且也提到了负载因子为0.75, 很多人并没有好好理解这段话的意思, 就强行将泊松分布于负载因子关联在一起。但是这段话的意思在于说明为什么TREEIFY_THRESHOLD的值会设置为8, 也就是为什么HashMap中链表长度超过8时才会转为红黑树, HashMap中TREEIFY_THRESHOLD的设定是为了尽可能的避免出现链表转红黑树的情况, 但是另一方面需要防止在恶意的数据规模中, 出现HashMap退化为链表的情况; 在注释中提到了负载因子, 这里的意思是, 注释中泊松分布的数据模型是基于负载因为为0.75的情况进行推演的;

对于为什么会默认为0.75, 目前还没有找到最严谨的推算方式, 也有说可以利用Hash碰撞通过二项式进行推算, 但是Hash碰撞并不完全符合二项分布的条件...

2. 关于HashMap中一些设计

(1) hash值的计算

不论是链表节点还是红黑树节点, 其中都维护着该节点key的hash值, 因为在hashMap的各个方法中都频繁的应用到了hash值; 在红黑树中计算索引时增加了扰动计算, 也就是在计算key的hash值后, 将key的的高16位与低16位进行异或运算, 减少hash碰撞

(2) 索引的计算

在计算索引时并没有使用%进行取模运算, 而是使用了hash值与hash表长度-1进行与运算来获取hash值对应的索引, 提高计算效率

hash: 1 0 1 0
&
tabCap-1: 1 1 1
=
index: 0 1 0

hash表容量为1000, 那么在hash值中低于第四位的值都是hashCap的模

(3)hash表容量必须为2的等次幂

根据上面索引的计算可以得出, 之后在hash表长度为2的等次幂, 在转为二进制数值后, 除了最高位其他位的数值均是0, 在tabCap-1, 所有位置的数值均为1, 与hash值进行与运算获取到模, 即索引

(4) 在链表长度超过8时, 链表可能会转为红黑树

HashMap每个桶中可能存在值的几率是0.5, 即λ = 0.5
泊松分布公式: exp(-0.5) * pow(0.5, k) / factorial(k)
多个节点经过hash计算索引后, 在出现hash冲突, 在同一个桶内的概率符合泊松分布
(注意:下面的数据模型是基于负载因子为0.75):

0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
more: less than 1 in ten million

当8个节点出现hash冲突在同一个桶内的概率为0.00000006, 所以在链表长度超过8的时候【可能】转为红黑树,
可见Hash表这样设计的本意是为了避免出现链表转为红黑树的情况

TREEIFY_THRESHOLD的设定是为了避免在出现链表转红黑树的情况, 但是另一方面需要防止在特定的数
据规模中,出现HashMap退化为链表导致查询效率急剧下降的情况

(5) 最小红黑树容量: MIN_TREEIFY_CAPACITY

HashMap中链表长度超过8的时候【可能】转为红黑树;
当链表长度超过8时, 首先判断hash表的长度是否大于最小红黑树容量(也就是hash表中出现红黑树需要达到的最小容量);
大于等于最小红黑树容量才会将链表转换为红黑树, 【如果小于, 则进行的是扩容操作, 而不是转换红黑树】

(6) String类型变量的hash值生成策略

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

示例:

字符串 java，由 j、a、v、a 四个字符组成
因此，java 的哈希值可以表示为 j ∗ n^3 + a ∗ n^2 + v ∗ n^1 + a ∗ n^0, 等价于 [ ( j ∗ n + a ) ∗ n + v ] ∗ n + a

在JDK中，乘数 n 为 31，为什么使用 31？
(1) 31符合2^n – 1，JVM会将 31 * i 优化成 (i << 5) – i
(2) 31是一个奇素数(既是奇数，又是素数，也就是质数), 素数和其他数相乘的结果比其他方式更容易产成唯一性，减少哈希冲突

还有其他在后面的源码解析中体现, 会有相关注明

3. HashMap相关定义

成员变量

/**
 * 桶; 存储链表的头节点的表, 或红黑树的根节点的表
 */
transient Node<K,V>[] table;  

/**
 * 存储缓存的set集合
 */
transient Set<Map.Entry<K,V>> entrySet;  

/**
 * HashMap中实际存储数据的数量
 */
transient int size;  

/**
 * HashMap结构上被修改的次数
 */
transient int modCount;  

/**
 * 阈值, 当size超过该阈值, 则进行扩容; ( 容量 * 负载系数 ) 16 * 0.75f = 12,
 */
int threshold;  

/**
 * 负载因子 0.75
 * 负载因子的用处, 最大可能的避免出现Hash冲突
 */
final float loadFactor;

基本属性默认值

/**
 * 默认初始化容量 - 必须为2的等次幂 (编译后面利用左移右移进行计算)
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
 * 最大容量, 必须小于2的30次方
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 默认负载因子为0.75
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 *
 * 当链表长度达到8时, 将链表转为红黑树;
 *  注意:  HashMap每个slot可能存在值的几率是0.5, 即λ = 0.5
 *        泊松分布公式: exp(-0.5) * pow(0.5, k) / factorial(k)
 *        多个节点经过hash计算索引后, 在出现hash冲突, 在同一个桶内的概率符合泊松分布
 *        (注意:下面的数据模型是基于负载因子为0.75):
 *
 *   0:    0.60653066
 *   1:    0.30326533
 *   2:    0.07581633
 *   3:    0.01263606
 *   4:    0.00157952
 *   5:    0.00015795
 *   6:    0.00001316
 *   7:    0.00000094
 *   8:    0.00000006
 *   more: less than 1 in ten million
 *
 *   当8个节点出现hash冲突在同一个桶内的概率为0.00000006, 所以在链表长度超过8的时候【可能】转为红黑树,
 *   可见Hash表这样设计的本意是为了避免出现链表转为红黑树的情况
 *
 *   TREEIFY_THRESHOLD的设定是为了避免在出现链表转红黑树的情况, 但是另一方面需要防止在特定的数
 *   据规模中,出现HashMap退化为链表导致查询效率急剧下降的情况
 *
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 当红黑树中的节点数量小于6时,红黑树将转换为链表
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 *
 *  HashMap中链表长度超过8的时候【可能】转为红黑树
 * 当链表长度超过8时, 首先判断hash表的长度是否大于最小红黑树容量(也就是hash表中出现红黑树需要达到的最小容量)
 *  大于等于最小红黑树容量才会将链表转换为红黑树, 【如果小于, 则进行的是扩容操作, 而不是转换红黑树】
 */
static final int MIN_TREEIFY_CAPACITY = 64;

链表节点

/**
 * Node节点,
 *    1.存储节点数据(key, value)
 *    2.存储key的hash值
 *    3.下一个节点的索引(用于链表模式下指向下一个节点, 单向链表)
 * 为什么使用单向链表?
 *    1. 节省内存, 仅存储下一个节点的地址即可
 *    2. 当出现hash值相同的key时, key会遍历该链表所有的节点, 判断是否存在相同的key,
 *    如果有, 则覆盖该节点. 如果查询至链表尾部, 仍然没有相同key,则就在该链表尾部新增节点
 */
static class Node<K,V> implements Map.Entry<K,V> {
	final int hash;  //存储key的hash值, 用于计算该key在Hash表中的索引位置
	final K key;     //key值, 不允许修改, 覆盖 (注:如果出现相同key,则直接覆盖value即可)
	V value;
	Node<K,V> next;  //下一个节点的地址

	Node(int hash, K key, V value, Node<K,V> next) {
		this.hash = hash;
		this.key = key;
		this.value = value;
		this.next = next;
	}

	public final K getKey()        { return key; }
	public final V getValue()      { return value; }
	public final String toString() { return key + "=" + value; }

	public final int hashCode() {
		//key的hash值与value的hash值的异或运算
		//异或运算: 0^0=0,0^1=1,1^0=1,1^1=0; 即: 参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0
		return Objects.hashCode(key) ^ Objects.hashCode(value);
	}

	public final V setValue(V newValue) {
		V oldValue = value;
		value = newValue;
		return oldValue;  //在更新value后, 会返回旧的value值
	}

	public final boolean equals(Object o) {
		if (o == this)
			return true;
		if (o instanceof Map.Entry) {
			Map.Entry<?,?> e = (Map.Entry<?,?>)o;
			//key与value都需要根据各自定义的equals方法认定为相同
			if (Objects.equals(key, e.getKey()) &&
				Objects.equals(value, e.getValue()))
				return true;
		}
		return false;
	}
}

红黑树节点

注意: 红黑树节点继承链表节点, 因此在红黑树中是维护着链表的前后顺序的

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // 父节点
    TreeNode<K,V> left;    //左子节点
    TreeNode<K,V> right;   //右子节点
    TreeNode<K,V> prev;    // 维持红黑树中节点的添加顺序 (注意: 在删除节点后, 需要取消连接)
    boolean red;           // 红黑树节点颜色, 默认为红色
    TreeNode(int hash, K key, V val, Node<K,V> next) {
        super(hash, key, val, next);
    }

    /**
     * 返回节点的根节点
     */
    final TreeNode<K,V> root() {
        for (TreeNode<K,V> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }
}

4. 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>[] tab;
    Node<K,V> p;
    int n, i;  //n: hash表的长度; i: 目标key在hash表中的索引
    if ((tab = table) == null || (n = tab.length) == 0)
       /**
        * 如果当前hash表为空, 或者长度为0 则初始化 【懒加载】
        */
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        /**
         * 如果对应hash桶的位置没有节点, 那么直接将当前节点放到此位置中
         * p为当前节点key的hash的索引值所对应的桶节点, 在判断语句中已经进行赋值操作
         */
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        /**
         * 如果当前桶节点的hash值与新增节点的hash值相同, 并且key也相同, 即覆盖当前节点的value即可
         */
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        /**
         * 【程序执行到这里】: 当前桶节点的key与新增节点的key不相同
         * 红黑树节点处理
         */
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); //如果在红黑树中存在相同key的节点, 那么这里会返回该节点, 便于后面统一进行覆盖操作
        /**
         * 链表节点处理
         */
        else {
            for (int binCount = 0; ; ++binCount) {  //计算当前链表的长度, 后面判断如果大于8, 需要转为红黑树
                /**
                 * 如果查找至链表尾部, 还未找到相同key, 那么直接添加至尾部即可;
                 * 这个也就是为什么新增的节点需要插入到链表尾部, 反正都要到达链表尾部的
                 */
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    /**
                     * 这里为什么要对TREEIFY_THRESHOLD-1?
                     * 因为在本次插入节点后, 链表的长度已经增长了1
                     */
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        /**
                         * 符合调条件, 当前链表可能需要转为红黑树
                         */
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    /**
                     * 【当程序执行到这里】: 待插入节点与链表中的某个节点的key一致! 因为在并发场景中, 可能在插入新节点之前其他线程已经插入了一个与当前节点相同key的节点,
                     * 为了保证hashmap中key的唯一性, 所以需要做最后的校验
                     */
                    break;
                p = e;
            } //for
        }
        /**
         * 【当程序执行到这里】: 如果e不为null, 那么说明在hashmap中存在于待插入的节点相同的key, 那么只需要覆盖该节点的value值即可
         */
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                /**
                 * 如果允许覆盖旧的value 或者 旧的value为bull 才会进行覆盖
                 */
                e.value = value;
            afterNodeAccess(e);  //linkedHashMap实现
            return oldValue; //返回覆盖的旧value值
        }
    }
    ++modCount;
    /**
     * 在添加新的元素后, 判断是否超过阈值, 如果超过, 则进行扩容
     */
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);//linkedHashMap实现
    return null;
}

5. HashMap节点的获取: get

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

/**
 *  根据key的hash值获取value
 */
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    /**
     * hash表不为空且长度大于0
     * 获取到根据hash计算索引,获取到第一个节点(该节点可能为链表节点或者红黑树根节点)
     */
    if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
        /**
         *  判断key是否相同的条件: 两个key的内存地址相同 或者 两个key通过equals方法判定为相同
         * 判断第一个节点是否是目标节点(注意:判断两个节点相同只能使用equals方法, 而compareTo()仅用于比较两个可比较节点的大小, 不能作为是否相同
         */
        if (first.hash == hash  &&  ((k = first.key) == key || (key != null && key.equals(k))) )
            return first;
        //如果头节点的下一个节点不为null才会去查找, 否则直接返回null
        if ((e = first.next) != null) {
            /**
             * 1.如果头节点为红黑树节点, 需要到红黑树找
             *   调用红黑树的方法获取并返回指定key的节点
             */
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            /**
             * 2. 如果头节点为链表, 循环遍历链表寻找目标节点
             */
            do {
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

6. HashMap的扩容:resize

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        /**
         *  旧hash表进行扩容
         */
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            /**
             * 新容量与新阈值均扩展为原数值的两倍
             */
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        /**
         * 【程序执行到这里】: 目标hash表的旧容量为空, 但是旧阈值不为空, 也就说明此时是需要进行初始化的
         *  而旧的阈值oldThr 就是 提前计算好需要的hash表的初始化容量
         */
        newCap = oldThr;
    else {
        /**
         * 【程序执行到这里】: 目标hash表的旧容量和旧阈值均为空, 需要将容量和阈值设置为默认值
         */
        newCap = DEFAULT_INITIAL_CAPACITY;  //默认容量:16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);  //默认阈值:12
    }

    if (newThr == 0) {
        /**
         * 【程序执行到这里】: 新的容量已经计算出来, 但是新的阈值还未进行计算
         */
        float ft = (float)newCap * loadFactor;  //新的容量 * 负载因子 = 新的阈值
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr; //更新阈值
    /**
     * 根据新的容量创建hash表
     */
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    /**
     * 如果就得hash表不为空, 那么需要进行元素挪动, 即需要把旧的hash表上的元素挪到新的hash表上
     */
    if (oldTab != null) {
        /**
         * 遍历旧的hash表的所有桶节点, 开始挪动元素
         */
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;  // e: 准备挪动的节点
            //如果该桶节点不为空,则开始挪动
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;  //清除原桶节点的引用
                if (e.next == null)
                    /**
                     * 如果桶节点的下一个节点为空, 那么说明该hash桶中只有一个节点, 直接计算新的索引, 然后挪动就可以了
                     *  注意:如果在旧的hash表中某个桶的位置只有一个元素, 那么在新的hash表中, 该元素所对应的新的hash桶位置也将只有一个元素
                     */
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    /**
                     * 如果当前节点是红黑树节点, 则强转为TreeNode节点, 利用红黑树性质挪动节点
                     */
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // 保持顺序
                    /**
                     * 如果当前节点是链表节点, 那么会根据索引位置将该链表拆为两个链表
                     */
                    Node<K,V> loHead = null, loTail = null;  //链表1
                    Node<K,V> hiHead = null, hiTail = null;  //链表2
                    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);
                    /**
                     * 将lo链表放到对应的hash桶中
                     */
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    /**
                     * 将hi链表放到对应的hash桶中
                     */
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

7.HashMap中节点的删除:remove

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {
    //tab:hash表, p:key所在hash桶的第一个节点(链表的首节点或者红黑树的根节点), n: 表的长度, index:索引
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            /**
             * 如果hash桶中的第一个节点就是待删除节点
             */
            node = p;
        else if ((e = p.next) != null) {
            /**
             * 待删除节点存在于链表或者红黑树中
             */
            if (p instanceof TreeNode)
                /**
                 * 待删除节点是红黑树节点,则找到这个节点
                 */
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                /**
                 * 遍历链表, 找到待删除的节点
                 */
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e; //p为前一个节点, e为即将要查找的节点
                } while ((e = e.next) != null);
            }
        }
        /**
         * 【当程序执行到这里】: node为待删除的节点, 可能为红黑树节点, 也可能为链表节点
         * 删除操作的前置条件:
         *    (1)待删除节点不为空
         *    (2)需要匹配value相同 并且 查找到的value和给定的value一致(内存地址一致或者equals判定为一致)
         *        或者
         *       不匹配value, 只要key相同就删除
         */
        if ( node != null &&
                (!matchValue || (v = node.value) == value || (value != null && value.equals(v) ) )
            ) {
            if (node instanceof TreeNode)
                /**
                 * 如果是红黑树节点
                 */
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                /**
                 * 如果hash桶中的第一个节点就是待删除节点
                 */
                tab[index] = node.next;
            else
                /**
                 * 如果是链表节点
                 * p为待删除节点的前一个节点, node为待删除节点
                 * 删除单向链表节点, 只修改next引用即可, 待删除节点的前一个节点的next属性指向待删除节点的下一个节点
                 */
                p.next = node.next;
            ++modCount;
            --size;  //size减一
            afterNodeRemoval(node);  //linkedHashMap实现
            return node;
        }
    }
    return null;
}

8.HashMap中红黑树相关方法

注意: 如果对红黑树不太理解可以先看着两篇播客(学习红黑树一定要先学会b树)

1. B-树

2. 红黑树

左旋转: rotateLeft

/**
 * 左旋转
 * 左旋转后发生了什么?
 *
 *  pp                  pp
 *  p         ==>       r
 *     r            p       rr
 *  rl   rr           rl
 */
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root, TreeNode<K,V> p) {
    TreeNode<K,V> r, pp, rl;   //r:p的右子节点, pp:p的父节点, rl: 右子节点的左子节点, rr:r节点的右子节点, 在旋转过程中, 其引用并未发生变化
    if (p != null && (r = p.right) != null) {
        if ((rl = p.right = r.left) != null)  //把r节点的左子节点移动到p的右子节点位置
            rl.parent = p;  //如果rl节点不为null, 那么需要维护一下rl的parent引用
        if ((pp = r.parent = p.parent) == null)  //将r节点的父节点更新为p的父节点pp, 如果p节点为根节点,那么需要染为黑色
            (root = r).red = false;  //r染为黑色
        else if (pp.left == p) //如果p节点是左子节点, 那么pp节点的左子节点更新为r节点
            pp.left = r;
        else
            pp.right = r;
        r.left = p;  //更新r节点左子节点为p
        p.parent = r;   //更新p的父节点为r
    }
    return root;
}

右旋转: rotateRight

/**
 * 右旋转
 * 右旋转后发生了什么?
 *
 *       pp              pp
 *       p     ==>       l
 *    l              ll       p
 * ll   lr                 lr
 */
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root, TreeNode<K,V> p) {
    TreeNode<K,V> l, pp, lr;   //l:p的右节点, pp:p的父节点, lr: l的右节点, ll:l的左节点, 因为在整个旋转过程中引用关系并没有发生改变
    if (p != null && (l = p.left) != null) {
        if ((lr = p.left = l.right) != null)  //如果lr节点不为null, 那么lr节点将作为p的左节点
            lr.parent = p;   //如果lr不为null, 那么更新lr的parent属性
        if ((pp = l.parent = p.parent) == null)  //将l节点的更新为p的父节点
            (root = l).red = false;  //如果p为根节点, 那么l节点需要置为黑色
        else if (pp.right == p)  //判断p为左子节点还是右子节点, 更新pp的left或者right属性
            pp.right = l;
        else
            pp.left = l;
        l.right = p;   //更新l的right属性
        p.parent = l;  //更新p的parent属性为l节点
    }
    return root;
}

插入后调整红黑树平衡:balanceInsertion

/**
 *  在红黑树插入节点后, 修复红黑树的性质
 *  root: 红黑树的新节点, x为新插入的节点
 *
 *【红黑树添加节点的12种情况】
 * 一些节点的定义:
 *      x:新增节点
 *      xp:新增节点的父节点
 *      xu: 新增节点的叔叔节点
 *      xpp:新增节点的祖父节点
 *      xppl:新增节点的祖父节点的左子节点 (新增节点的父节点或者叔叔节点)
 *      xppr:新增节点的祖父节点的右子节点 (新增节点的父节点或者叔叔节点)
 *
 * 【1】  xp节点为黑色, xp节点度为 0, x节点为左子节点  ==> 无需调整
 * 【2】  xp节点为黑色, xp节点度为 0, x节点为右子节点  ==> 无需调整
 * 【3】  xp节点为黑色, xp节点度为 1, x节点为左子节点  ==> 无需调整
 * 【4】  xp节点为黑色, xp节点度为 1, x节点为右子节点  ==> 无需调整
 *                                                                                               注意:这里的xp节点为旋转之后的xp节点, x节点为旋转之后的x节点
 * 【5】  xp节点为红色, xp节点度为 0, xp节点为(左)子节点, xpp节点为黑色, xpp节点度为 (1), x节点为(左)子节点  ==> xp节点右旋转, xp染为黑色, xpp染为红色
 * 【6】  xp节点为红色, xp节点度为 0, xp节点为(左)子节点, xpp节点为黑色, xpp节点度为 (1), x节点为(右)子节点  ==> xp节点先左旋转, 再右旋转, x染为黑色, xpp染为红色
 * 【7】  xp节点为红色, xp节点度为 0, xp节点为(右)子节点, xpp节点为黑色, xpp节点度为 (1), x节点为(左)子节点  ==> xp节点先右旋转, 再左旋转, x染为黑色, xpp染为红色
 * 【8】  xp节点为红色, xp节点度为 0, xp节点为(右)子节点, xpp节点为黑色, xpp节点度为 (1), x节点为(右)子节点  ==> xp节点左旋转, xp染为黑色, xpp染为红色
 *
 * 【9】  xp节点为红色, xp节点度为 0, xp节点为(左)子节点, xpp节点为黑色, xpp节点度为 (2), x节点为(左)子节点  ==> xp染为黑色, xu染为黑色, xpp染为红色, 然后以 xpp为新增节点x继续修复红黑树性质
 * 【10】 xp节点为红色, xp节点度为 0, xp节点为(左)子节点, xpp节点为黑色, xpp节点度为 (2), x节点为(右)子节点  ==> xp染为黑色, xu染为黑色, xpp染为红色, 然后以 xpp为新增节点x继续修复红黑树性质
 * 【11】 xp节点为红色, xp节点度为 0, xp节点为(右)子节点, xpp节点为黑色, xpp节点度为 (2), x节点为(左)子节点  ==> xp染为黑色, xu染为黑色, xpp染为红色, 然后以 xpp为新增节点x继续修复红黑树性质
 * 【12】 xp节点为红色, xp节点度为 0, xp节点为(右)子节点, xpp节点为黑色, xpp节点度为 (2), x节点为(右)子节点  ==> xp染为黑色, xu染为黑色, xpp染为红色, 然后以 xpp为新增节点x继续修复红黑树性质
 *
 * ##为什么没有父节点为黑色, 父节点度为 2的情况 ?
 *  因为如果父节点为2, 那么还哪还有位置插入新的节点... 红黑树也是一个二叉树
 *
 * ##为什么没有父节点为红色, 父节点度不为 0 的情况 ?
 *  因为如果父节点为红色,且度不为 0, 那么这棵红黑树将不满足性质4 "RED节点的子节点都是BLACK"
 *  具体原因可以按照红黑树推导4阶B树分析:
 *       如果父节点为红色, 那么该节点将跟它的黑色节点合为一个B树节点, 如果 父节点为红色,且度不为 0, 那么红黑树将无法推导为一个标准的4阶B树
 */
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root, TreeNode<K,V> x) {
    /**
     * 默认插入的新节点为红色
     * 为什么是红色呢 ?
     *   因为默认为红色,可以满足红黑树五大性质中的四条,"RED节点的子节点都是BLACK" 这条除外
     */
    x.red = true;
    for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
        /**
         * xp:新增节点的父节点
         * xu:新增节点的叔叔节点
         * xpp:新增节点的祖父节点
         * xppl:新增节点的祖父节点的左子节点 (新增节点的父节点或者叔叔节点)
         * xppr:新增节点的祖父节点的右子节点 (新增节点的父节点或者叔叔节点)
         */
        if ((xp = x.parent) == null) {
            x.red = false; //如果新增节点的父节点为空, 那么新增节点为根节点, 红黑树中根节点必须为黑色, 直接返回即可
            return x;
        }
        /**
         * 添加节点不为根节点情况
         */
        else if (!xp.red || (xpp = xp.parent) == null)
            /**
             * xp节点为黑色, 或者父节点为root节点(黑色), 不需要调整
             *  情况:【1】【2】【3】【4】
             */
            return root;

        if (xp == (xppl = xpp.left)) {
            /**
             * xp节点为左子节点
             */
            if ((xppr = xpp.right) != null && xppr.red) {
                /**
                 * [xp节点为左子节点], xpp节点的度为 2, xu节点为红色
                 * 注意: 此时xu节点必为红色, 如果为黑色,则该红黑树将不满则性质"从任一节点到叶子节点的所有路径都包含相同数目的 BLACK节点"
                 * 情况:【9】【10】
                 */
                xppr.red = false;  //xu节点染为黑色
                xp.red = false;    //父节点染为黑色
                xpp.red = true;    // 祖父节点染为红色
                x = xpp;    // 将xpp节点当做新增节点,调整红黑树平衡 (4阶B树中的上溢)
            }
            else {
                /**
                 * [xp节点为左子节点], xpp节点的度为 1
                 * 情况【6】
                 */
                if (x == xp.right) {
                    /**
                     * [xp节点为左子节点, xpp节点的度为 1], x节点为右子节点(1)  ==>左旋转
                     */
                    root = rotateLeft(root, x = xp);  //先进行左旋转
                    //左旋之后,需要更新xp和xpp的引用节点为: 现xp节点为原x节点, 现x节点为原xp节点, xpp节点为现xp节点(原x节点)的父节点
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }


                if (xp != null) {
                    /**
                     * [xp节点为左子节点, xpp节点的度为 1], x节点为左子节点
                     * 情况:【5】
                     * [xp节点为左子节点, xpp节点的度为 1], x节点为右子节点(2)  ==>右旋转
                     * 情况:【6】
                     */
                    xp.red = false;               //xp节点(原x节点)染为黑色
                    if (xpp != null) {
                        xpp.red = true;           //xpp节点染为红色
                        root = rotateRight(root, xpp);  //再进行右旋转
                    }
                }
            } //else
        }

        /**
         * xp节点为右子节点
         */
        else {
            if (xppl != null && xppl.red) {
                /**
                 * [xp节点为右子节点], xpp节点度为 2, xu节点为红色
                 * 情况【11】【12】
                 */
                xppl.red = false;  //xu节点染为黑色
                xp.red = false;    //xp节点然为黑色
                xpp.red = true;    //xpp染为红色
                x = xpp;   // 将xpp节点当做新增节点,调整红黑树平衡 (4阶B树中的上溢)
            }
            else {
                /**
                 * [xp节点为右子节点], xpp节点度为 1
                 */
                if (x == xp.left) {
                    /**
                     * [xp节点为右子节点, xpp节点度为 1], x节点为左子节点(1)
                     */
                    root = rotateRight(root, x = xp);  //右旋转
                    //右旋之后,需要更新xp和xpp的引用节点为: 现xp节点为原x节点, 现x节点为原xp节点, xpp节点为现xp节点(原x节点)的父节点
                    xpp = (xp = x.parent) == null ? null : xp.parent;
                }
                if (xp != null) {
                    /**
                     *  [xp节点为右子节点, xpp节点度为 1], x节点为右子节点
                     *  情况:【8】
                     *  [xp节点为右子节点, xpp节点度为 1], x节点为左子节点(2)
                     *  情况:【7】
                     */
                    xp.red = false;  // xp染为黑色
                    if (xpp != null) {
                        xpp.red = true; //xpp染为红色
                        root = rotateLeft(root, xpp);
                    }
                }
            }
        }
    }
}

删除后调整红黑树平衡:balanceDeletion

/**
 * 在红黑树删除节点后, 修复红黑树
 */
static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root, TreeNode<K,V> x) {
    /**
     * x:   待移除节点被删除后的替换节点
     * xp:  父节点
     * xpl: 父节点的左子节点
     * xpr: 父节点的右子节点
     * 【当成程序执行到这里】: 如果待删除节点是度不为0的节点, 那么此节点已经被删除, 而顶替节点也已经替代了已经删除节点, 由于此时红黑树可能已经失去平衡, 所以需要进行维护
     */
    for (TreeNode<K,V> xp, xpl, xpr;;)  {
        if (x == null || x == root)
            /**
             * 如果x节点现在是根节点, 则无需调整
             */
            return root;
        else if ((xp = x.parent) == null) {
            /**
             * 替换节点为根节点, 染为黑色
             */
            x.red = false;
            return x;
        }
        /**
         * 【删除场景 1】:被删除节点存在一个红色的子节点,在删除后, 该子节点替代被删除节点的位置, 所以改为黑色即可
         * 如果替换节点为红色; 那么仅需要染为黑色, 红黑树就达到了平衡, 退出循环
         */
        else if (x.red) {
            x.red = false;
            return root;
        }
        /**
         *  [x节点为左子点] 因为x节点所处位置不一样, 后面的旋转方式也不一样
         * 【删除场景 2】:被删除节点为黑色叶子节点 (即:x节点的度为0, 不存在可以替换的子节点)
         * 【程序执行到这里】: 此时x节点还没有删除, 需要先调整红黑树性质, 再删除
         */
        else if ((xpl = xp.left) == x) {

            if ((xpr = xp.right) != null && xpr.red) {
                /**
                 * 【删除场景 2.1】:被删除节点为黑色叶子节点, 并且兄弟节点为红色, 需要将兄弟节点转为黑色
                 */
                xpr.red = false;  //兄弟节点染为黑色
                xp.red = true;    //父节点染为红色
                root = rotateLeft(root, xp);  //在经过左旋转后, x,xp节点的情况为:x节点为左子节点, xp节点度为 2, 兄弟节点为黑色
                xpr = (xp = x.parent) == null ? null : xp.right;
            }
            /**
             * 【删除场景 2.2】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色
             */
            if (xpr == null)
                x = xp;
            else {
                TreeNode<K,V> sl = xpr.left, sr = xpr.right;
                if ((sr == null || !sr.red) && (sl == null || !sl.red)) {
                    /**
                     * 【删除场景 2.2.1】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色,兄弟节点 没有 红色子节点
                     */
                    xpr.red = true; //兄弟节点染为红色, 第一次执行到此处时:不用更新x(p)节点的颜色, 后面p节点会被删除
                    x = xp;        // 把xp赋给x, 把xp当做被删除的节点, 继续向上修复红黑树 (基于4阶B树,出现下溢情况)
                }
                else {
                    /**
                     * 【删除场景 2.2.2】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色,兄弟节点 有 红色子节点
                     */
                    if (sr == null || !sr.red) {
                        if (sl != null)
                            sl.red = false;  //如果兄弟节点的另一个左子节点不为空, 染为黑即可, 在右旋转之后, sl节点将作为新xp节点的左子节点
                        xpr.red = true;  //兄弟节点染红, 因为兄弟节点会替代原xp节点, 而原xp节点为红色
                        root = rotateRight(root, xpr); //右旋转
                        xpr = (xp = x.parent) == null ? null : xp.right;
                    }
                    /**
                     * 兄弟节点不为空,则兄弟节点需要继承原xp节点的颜色
                     */
                    if (xpr != null) {
                        xpr.red = (xp == null) ? false : xp.red;
                        if ((sr = xpr.right) != null)
                            sr.red = false;
                    }
                    /**
                     * 如果原xp节点不为null, 则需要将原xp节点染为黑色
                     */
                    if (xp != null) {
                        xp.red = false;
                        /**
                         * 如果兄弟节点有两个红色节点, 那么还需要一次右旋,恢复平衡
                         */
                        root = rotateLeft(root, xp);
                    }
                    x = root;
                }
            }
        }
        /**
         *   [x节点为右子点] 因为x节点所处位置不一样, 后面的旋转方式也不一样
         * 【删除场景 2】:被删除节点为黑色叶子节点 (即:x节点的度为 0, 不存在可以替换的子节点)
         * 【程序执行到这里】: 此时x节点还没有删除, 需要先调整红黑树性质, 再删除
         */
        else { // symmetric
            /**
             * 【删除场景 2.1】:被删除节点为黑色叶子节点, 并且兄弟节点为红色, 需要将兄弟节点转为黑色
             */
            if (xpl != null && xpl.red) {
                xpl.red = false;  //兄弟节点染为黑色
                xp.red = true;    //父节点染为红色
                root = rotateRight(root, xp);  //以xp进行右旋转, 旋转之后, 原兄弟节点为原xp节点的父节点
                xpl = (xp = x.parent) == null ? null : xp.left;
            }
            /**
             * 【删除场景 2.2】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色
             */
            if (xpl == null)
                x = xp;
            else {
                TreeNode<K,V> sl = xpl.left, sr = xpl.right;  //sl:兄弟节点的左子节点, sr:兄弟节点右子节点
                if ((sl == null || !sl.red) && (sr == null || !sr.red)) {
                    /**
                     * 【删除场景 2.2.1】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色,兄弟节点 没有 红色子节点
                     */
                    xpl.red = true;   //兄弟节点染为红色, 第一次执行到此处时:不用更新x(p)节点的颜色, 后面p节点会被删除
                    x = xp;           // 把xp赋给x, 把xp当做被删除的节点, 继续向上修复红黑树 (基于4阶B树,出现下溢情况)
                }
                else {
                    /**
                     * 【删除场景 2.2.2】:被删除节点为黑色叶子节点, 并且兄弟节点为黑色,兄弟节点 有 红色子节点
                     * [x节点为右子点]
                     */
                    if (sl == null || !sl.red) {  //兄弟节点的右子节点为红色 (根据【删除场景 2.2.1】条件推算)
                        if (sr != null)
                            sr.red = false;
                        xpl.red = true;
                        root = rotateLeft(root, xpl);  //左旋转, sr节点替环xp节点, xp节点替换x节点  (在旋转后:sr为父节点,xp为右子节点, sl为左子节点)
                        xpl = (xp = x.parent) == null ? null : xp.left;  //更新xpl节点
                    }
                    /**
                     * 兄弟节点不为空,则兄弟节点需要继承原xp节点的颜色
                     */
                    if (xpl != null) {
                        xpl.red = (xp == null) ? false : xp.red;
                        if ((sl = xpl.left) != null)
                            sl.red = false;  //sl节点染为黑色
                    }
                    /**
                     * 如果原xp节点不为null, 则需要将原xp节点染为黑色
                     */
                    if (xp != null) {
                        xp.red = false;
                        /**
                         * 如果兄弟节点有两个红色节点, 那么还需要一次右旋,恢复平衡
                         */
                        root = rotateRight(root, xp);
                    }
                    x = root;
                }//else
            }
        }
    } //for
}

检查红黑树: checkInvariants

/**
 * 验证红黑树的准确性
 */
static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
    // tp:父节点, tl:左子节点, tr:右子节点, tb:前驱节点, tn:后继节点
    TreeNode<K,V> tp = t.parent, tl = t.left, tr = t.right,
        tb = t.prev, tn = (TreeNode<K,V>)t.next;
    /**
     * 当出现以下任一情况时, 红黑树或者双向链表不正确
     */

    /**
     * 1、如果前驱节点存在, 但是前驱节点的后继节点不是当前节点
     */
    if (tb != null && tb.next != t)
        return false;
    /**
     * 2、如果后继节点存在, 但是后继节点的前驱节点不是当前节点
     */
    if (tn != null && tn.prev != t)
        return false;
    /**
     * 3、父节点存在, 但是父节点的左子节点、右子节点均不是当前节点
     */
    if (tp != null && t != tp.left && t != tp.right)
        return false;
    /**
     * 4、左子节点存在, 但是左子节点的父节点不是当前节点或者左子节点的hash值大于当前节点的hash值
     */
    if (tl != null && (tl.parent != t || tl.hash > t.hash))
        return false;
    /**
     * 5、右子节点存在, 但是右子节点的父节点不是当前节点或者右子节点的hash值小于当前节点的hash值
     */
    if (tr != null && (tr.parent != t || tr.hash < t.hash))
        return false;
    /**
     * 6、当前节点是红色,孩子节点也是红色  ==>红黑树性质
     */
    if (t.red && tl != null && tl.red && tr != null && tr.red)
        return false;
    /**
     * 递归验证左子树
     */
    if (tl != null && !checkInvariants(tl))
        return false;
    /**
     * 递归验证右子树
     */
    if (tr != null && !checkInvariants(tr))
        return false;
    /**
     * 通过验证, 返回true
     */
    return true;
}
}

AnEra

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
HashMap源码深度分析(JDK1.8)

目录1. 网上关于HashMap的一些问题的错误解析2. 关于HashMap中一些设计(1) hash值的计算(2) 索引的计算(3)hash表容量必须为2的等次幂(4) 在链表长度超过8时, 链表可能会转为红黑树(5) 最小红黑树容量: MIN_TREEIFY_CAPACITY3. HashMap相关定义成员变量基本属性默认值链表节点红黑树节点4. HashMap节点的添加: put相关方法1: putTreeVal相关方法2: treeifyB
复制链接

扫一扫