HashMap源码分析

·  阅读 310

前言

本文是1.8版本的HashMap源码解析,包含散列函数,扰乱函数,容量开辟,红黑树平衡原理,链表下标位移原理,左旋右旋原理等内容。

目录

[TOC]

简介

  • HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。

  • HashMap 本质是数组加链表(链表长度大于8则转换为红黑树)形式实现的。

  • HashMap 继承于AbstractMap,实现了Map、Cloneable、java.io.Serializable接口。

  • HashMap 不是线程安全的。它的key、value都可以为null。此外,HashMap中的映射不是有序的。

    关系如下:

    java.lang.Object
       ↳     java.util.Map<K,V>
             ↳     java.util.AbstractMap<K,V>
                   ↳     java.util.HashMap<K,V>
    
    public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{}
    复制代码

    java集合框架图如下:

HashMap结构图如下:

一、HashMap属性解析

我们跟踪源码看到如下属性

private static final long serialVersionUID = 362498820763181265L
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4
static final int MAXIMUM_CAPACITY = 1 << 30
static final float DEFAULT_LOAD_FACTOR = 0.75f
static final int TREEIFY_THRESHOLD = 8
static final int UNTREEIFY_THRESHOLD = 6
static final int MIN_TREEIFY_CAPACITY = 64
transient Node<K,V>[] table
transient Set<Map.Entry<K,V>> entrySet
transient int size
transient int modCount
int threshold
复制代码

1.DEFAULT_INITIAL_CAPACITY

​ 默认初始化容量

2.MAXIMUM_CAPACITY

​ 最大容量

3.DEFAULT_LOAD_FACTOR

​ 默认负载因子

4.TREEIFY_THRESHOLD

​ 链表转换为红黑树的阈值,即如果链表长度超过8转为红黑树

5.UNTREEIFY_THRESHOLD

​ 红黑树转为链表的阈值,即如果红黑树长度小于等于6则转为链表

6.MIN_TREEIFY_CAPACITY

​ 最小红黑树容量

7.table

​ Node节点数组

8.entrySet

​ 特殊的Set,这个Set使用EntryIterator遍历,而这个Iterator则直接操作于HashMap的内部存储结构table上。通过这种方式实现了“视图”的功能。整个过程不需要任何辅助存储空间。

9.size

​ 大小

10.modCount

​ Fail-Fast机制

11.threshold

​ 扩容阈值(size*DEFAULT_LOAD_FACTOR)

12.serialVersionUID

​ 此属性是序列化UID,Java序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。 在进行反序列化,Java虚拟机会把传过来的字节流中的serialVersionUID和本地相应实体类的serialVersionUID进行比较, 如果相同就认为是一致的实体类,可以进行反序列化,否则Java虚拟机会拒绝对这个实体类进行反序列化并抛出异常。


二、HashMap.hash()

散列函数

首先进行hash概念进行讲解,为下文分析做出铺垫。首先引用一段维基百科的解释。

散列函数(英语:Hash function)又称散列算法哈希函数,是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要,使得数据量变小,将数据的格式固定下来。该函数将数据打乱混合,重新创建一个叫做散列值(hash values,hash codes,hash sums,或hashes)的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。[1]好的散列函数在输入域中很少出现散列冲突。在散列表数据处理中,不抑制冲突来区别数据,会使得数据库记录更难找到。

如今,散列算法也被用来加密存在数据库中的密码(password)字符串,由于散列算法所计算出来的散列值(Hash Value)具有不可逆(无法逆向演算回原本的数值)的性质,因此可有效的保护密码。

在本次解析之中,hash的应用其实是key.hashcode()获取key的散列值(唯一值)

下标计算

计算key.hashCode()并将哈希值的高位与低位做异或

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
复制代码

JAVA7之中其实是四次异或,在JAVA8之中已经做了简化了。其原理是不变的

  • 首先要说明的是key.hashCode()函数调用的是key自带的哈希函数,返回Int型散列值,但是如果直接拿散列值作为下标访问HashMap数组的话,映射空间就为**-21474836482147483648**,即为40亿的映射空间,但是这个长度的数组内存是放不下的。所以要对数组的长度取模运算。即散列值和数组的长度-1做操作,代码如下。
(n - 1) & hash
复制代码

n为length

  • 其次要说明的是为什么HashMap的长度要取2的整次幂,因为长度-1正好相当于一个低位掩码。“与”操作的结果就是散列值的高位全部归零,只保留低位值,用来做数组下标访问。以初始长度16为例,16-1=15。2进制表示是00000000 00000000 00000000 00001111。和某散列值做操作如下,结果就是截取了最低的四位值。过程如下。
		11011111 01111110 10101111 11010101
&		00000000 00000000 00000000 00001111(n-1)
------------------------------------------------------
		00000000 00000000 00000000 00000101
复制代码
  • 根据结果看到,其实保留的就是最低的四位值。如果直接拿此值去当作下标,显然碰撞会十分严重。如果是等差数列形的分布,最后几位为规律性重复,则误解。此时扰乱函数的作用就体现出了。过程如下。
step1:调用key.hashCode()并复制给h
			11011111 01111110 10101111 11010101 [h = key.hashCode()]
------------------------------------------------------------------
step2:将h的高位与低位做异或(与无符号右移的h做异或)
			11011111 01111110 10101111 11010101 [h]
		 	00000000 00000000 11011111 01111110 [h >>> 16]
		 	00000000 00000000 01110000 10101011 ^
------------------------------------------------------------------
step3:将结果与n(数组长度)-1做与
			00000000 00000000 01110000 10101011
			00000000 00000000 00000000 00001111	&  	    
------------------------------------------------------------------
			00000000 00000000 00000000 00001011
复制代码
  • 扰乱函数很巧妙的通过16位无符号右移,让自己的高低位做异或,使高低位做特征对比,保留了部分高位的特征,也加大了结果的随机性。然后与(n-1)做与操作,结果也就是保留了最低的四位。

最后在引用一篇An introduction to optimising a hashing strategy。作者随机选取了352个字符串,在他们散列值完全没有冲突的前提下,对它们做低位掩码,取数组下标。结果如下。

当HashMap长度为512位,如果取低9位,没有扰动函数,有103次碰撞。加入扰乱函数则降低为92次。减少近10%

JAVA8把扰乱函数从四次降低为一次,侧面印证了多做几次意义不大。


三、HashMap构造方法

​ HashMap有四个构造,我们逐个解析,我们先解析其中三个的实现。

1.HashMap()

​ 空构造

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
复制代码

​ 空构造的情况下对负载因子赋默认值,即0.75


2.HashMap(int initialCapacity)|HashMap(int initialCapacity, float loadFactor)

带初始参数的构造

public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +  initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +  loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
}

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;
}
复制代码
  • 如果指定了初始容量或者同时指定了扩容因子,则首先做基本验证。如初始容量是否大于0,是否小于最大值。通过验证会计算扩容阈值。

  • 扩容阈值为大于等于initialCapacity的最小的2的整数次幂(initialCapacity如果就是2的幂,则返回的还是这个数)。

    图解如下

总结

  • 只有在指定了默认容量参数或者同时指定了扩容因子,才会在构造时计算出扩容阈值。
  • 扩容阈值的计算是通过5次无符号右移实现的求初始容量的最小2的整数次幂。

四、添加方法

1. put(K key, V value)|putIfAbsent(K key, V value)

​ put(K key, V value)和putIfAbsent(K key, V value)其实都是调用putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}
public V putIfAbsent(K key, V value) {
        return putVal(hash(key), key, value, true, true);
}
复制代码

​ putVal内部逻辑比较复杂,我们分段解析

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还未初始化,则通过resize()开辟空间
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
    	//如果通过扰乱函数计算出的下标获得Value元素为空则直接添加节点
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //如果找到已存在的元素则替换(key和hash和目标元素的key和hash都相同)
            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;
                    }
                     //如果找到已存在的元素则替换(key和hash和目标元素的key和hash都相同)
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //这段处理就是putIfAbsent的单独处理模块
            //如果为true则,找到已存在的元素并不更新值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
    	//Fail-Fast机制
        ++modCount;
    	//如果新增元素后的size大于扩容阈值则重新开辟空间
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
}
复制代码

根据分析得出以下结论:

  • 如果table未初始化,则通过resize()初始化
  • onlyIfAbsent参数如果为true,则插入节点已存在并不更新新值。否则更新为新值。
  • 如果节点为红黑树节点,则调用**putTreeVal()**方法实现红黑树插入。
  • 如果不是红黑树并不存在key相同的元素则通过链表尾插形式插入新节点。
    • 如果链表超过转换红黑树的阈值,则调用**treeifyBin()**方法转换为红黑树。
  • 如果新节点插入之后大于了扩容阀值则调用resize()扩容。

根据结论发现,table初始化和扩容都是掉头用resize()方法。

红黑树插入的方法为putTreeVal()。

链表转换为红黑树的方法为treeifyBin()。

接下来我们分析resize()方法。resize()方法内部其实就包含了红黑树转换,红黑树平衡,红黑树插入的实现


五、resize()

​ resize()是十分重要的方法,内部逻辑还是较为复杂的,所以我们把方法分为多个部分,并新起一章,分段解析。

​ 分段如下:

  • 重新开辟容量大小计算过程
  • 重新分配节点到对应位置
    • 数组分配
    • 红黑树分配
    • 链表分配
final Node<K,V>[] resize() {
    	//------1.空间开辟begin------
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            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
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
    	//------1.空间开辟end------
    
    	//------2.重新分配节点到对应位置begin------
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //------2.1数组分配begin------
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //------2.1数组分配end------
                    
                    //------2.2红黑树分配begin------
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //------2.2红黑树分配end------
                    
                    //------2.3链表分配begin------
                    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;
                        }
                    }
                }
                //------2.3链表分配end------
            }
        }
        return newTab;
    	//------2.重新分配节点到对应位置end------
}
复制代码

1.创建新数组

在HashMap初始化和扩容的时候都会调用此方法,首先第一段为根据具体情况计算出需要创建的HashMap的容量和扩容阈值。下文解析会围绕两种情况做出分析。

//1为无initialCapacity初始化容量
//2为指定了initialCapacity初始化容量
//3为扩容
//获取旧table的引用,长度,容量,扩容阈值
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//创建新的容量,阈值的变量
int newCap, newThr = 0;
if (oldCap > 0) {
    //3
    if (oldCap >= MAXIMUM_CAPACITY) {
        //如果旧容量大于容量最大限制则给扩容阈值设置为Integer.MAX_VALUE
    	//并返回旧table
         threshold = Integer.MAX_VALUE;
         return oldTab;
    }
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
        //3
        //对新容量赋值为旧容量的2倍
    	//如果新容量小于容量最大限制,并且旧容量大于或等于默认容量(16)则给新扩容阈值同赋值为旧容量的2倍
         newThr = oldThr << 1;
}else if (oldThr > 0) 
    //2
	//如果指定了initialCapacity,则threshold为大于initialCapacity的最小的2的次幂
	//(oldThr > 0)为如果指定了initialCapacity,则用threshold作为table的实际大小
    newCap = oldThr;
else { 
     //1
     //如果没有指定initialCapacity,则为默认空间大小
	 //并且扩容阈值赋值为扩容因子*默认空间大小
     newCap = DEFAULT_INITIAL_CAPACITY;
     newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { 
     //1
     //为扩容阈值赋值为新容量的0.75倍(小于最大容量的情况)
     float ft = (float)newCap * loadFactor;
     newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
}
//根据计算出的容量创建新的数组,并更新阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
复制代码

最后总结如下

  • 如果在初始化情况下,并构造函数没有指定initialCapacity,则进入分支1,table大小为16,扩容阈值为16*0.75。
  • 如果在初始化情况下,并构造函数指定了initialCapacity,则进入分支2,则table大小为threshold, 即大于指定initialCapacity的最小的2的整数次幂。
  • 如果是扩容情况,则进入分支3,对新容量赋值为旧容量的2倍。

2.赋值过程

2.1 纯数组情况

赋值过程其实是通过节点迭代完成的,只不过内部有分为三种情况处理,我们本段解析先说明是如何通过next添加到纯数组的结构(也就是没有hash冲撞的情况)。

if (oldTab != null) {
    for (int j = 0; j < oldCap; ++j) {
        //创建节点
        Node<K,V> e;
        //e赋值迭代节点
        if ((e = oldTab[j]) != null) {
            //如果迭代的节点不NULL
            //给迭代节点制空,CG回收
            oldTab[j] = null;
            if (e.next == null) newTab[e.hash & (newCap - 1)] = e;//如果e节点的.next节点为空,则为纯数组,直接通过下标添加。
        }
        //后续代码从此继续
    }
}
复制代码

2.2 链表情况

此段代码较为复杂,首先先说出大体的逻辑。

  1. 根据上文分析,如果next节点为空则等于在此下标下有多个元素(链表结构),并且不等于红黑树会进入此分支
  2. 下段代码会通过某种方式确定新HashMap(扩容后的HashMap)那些节点是下标没有发生变化的,那些是发生变化的,并根据放置到两组不同的链表之中。
  3. 最终通过某种方式把两组链表添加至两个对应下标

此时我们有两个问题

  • 插入到不同链表的条件?
  • 如何计算两组链表要添加到的下标?
//lo链表的头节点和尾节点
Node<K,V> loHead = null, loTail = null;
//hi链表的头节点和尾节点
Node<K,V> hiHead = null, hiTail = null;
//迭代节点
Node<K,V> next;
do {
   next = e.next;
   if ((e.hash & oldCap) == 0) {//关键点
       //插入至lo链表
       if (loTail == null)
            loHead = e;
       else
            loTail.next = e;
       loTail = e;
   }
   else {
       //插入到hi链表
       if (hiTail == null)
            hiHead = e;
       else
            hiTail.next = e;
       hiTail = e;
   }
} while ((e = next) != null);
if (loTail != null) {
   //如果lo链表不为空则添加到[j]位
   loTail.next = null;
   newTab[j] = loHead;
}
if (hiTail != null) {
   //如果hi链表不为空则添加到[j+oldCap]位
   hiTail.next = null;
   newTab[j + oldCap] = hiHead;
}
复制代码

根据源码分析,得到结果。

  • ((e.hash & oldCap) == 0)将节点插入到lo链表,否则添加到hi链表。下文做出此条件的分析。

    首先要明确几点:

    1. oldCap一定是2的整数次幂, 假设是2^m
    2. newCap是oldCap的两倍, 则会是2^(m+1)
    3. hash对数组大小取模**(n - 1) & hash** 其实就是取hash的m

    所以假设oldCap为32,newCap为64,即:

    oldCap=32		
    oldCap-1=31		0000 0000 0000 0000 0000 0000 0001 1111
    ----------------------------------------------------------------------
    newCap=64
    newCap-1=63		0000 0000 0000 0000 0000 0000 0011 1111
    复制代码

    此时,(newCap-1&hash)的结果只可能是首位是0或者是1加任意四位0或1,假设结果是011010和111010两种情况,得出以下两种结论。

    • 结果为011010则和(oldCap-1&hash)结果一致,即位置不变,为lo链表,下标为j
    • 结果为111010则和(oldCap-1&hash)+10000一致,即位置发生变化,hi链表,下标为j+oldcap

    图解如下


2.3 红黑树情况

如果迭代节点是TreeNode类型则调用split方法,内部基本逻辑如下。
复制代码
  1. 还是通过(e.hash & oldCap) 取模,如果为0则将数据添加到lo链表(下标未变),否则添加到hi链表(下标变化)
  2. 如果链表长度小于等于UNTREEIFY_THRESHOLD(6)则转为普通链表
  3. 如果链表长度大于UNTREEIFY_THRESHOLD(6)则红黑树化。
else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    //lo链表的头节点和尾节点
    TreeNode<K,V> loHead = null, loTail = null;
    //hi链表的头节点和尾节点
    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;
          //bit就是oldCap,即(e.hash & oldCap)==0则为下标无变化
          if ((e.hash & bit) == 0) {
               //如果迭代节点的prev(上一个节点)为空,则为头节点
               if ((e.prev = loTail) == null)
                   loHead = e;
               else
                   loTail.next = e;
               loTail = e;
               //链表长度前++
               ++lc;
           }
           //(e.hash & oldCap)!=0则为新位置,新位置就是index+oldCap
           else {
               //逻辑和lo节点赋值一致
               if ((e.prev = hiTail) == null)
                   hiHead = e;
               else
                   hiTail.next = e;
               hiTail = e;
               ++hc;
           }
    }
    //如果lo链表头节点不为空(lo链表不为空)
    if (loHead != null) {
           //lo链表长度小于等于UNTREEIFY_THRESHOLD(不需要红黑树化的阈值 6)
           if (lc <= UNTREEIFY_THRESHOLD)
               //根据下标创建对应的单链表
               tab[index] = loHead.untreeify(map);
           else {
               tab[index] = loHead;
               if (hiHead != null) // (else is already treeified)
                   //转为红黑树
                   loHead.treeify(tab);
           }
    }
    //此段代码逻辑和上文lo链表逻辑相同
    if (hiHead != null) {
           if (hc <= UNTREEIFY_THRESHOLD)
               tab[index + bit] = hiHead.untreeify(map);
           else {
               tab[index + bit] = hiHead;
               if (loHead != null)
                   hiHead.treeify(tab);
           }
    }
}
复制代码

根据上文分析,得出如果转为单链表则调用untreeify(map)方法。如果转为红黑叔则调用treeify(tab)方法。


2.3.1.untreeify(map)
首先分析untreeify(map)方法
复制代码
final Node<K,V> untreeify(HashMap<K,V> map) {
     Node<K,V> hd = null, tl = null;
     //将传入的红黑树迭代
     for (Node<K,V> q = this; q != null; q = q.next) {
          //将迭代节点替换为普通节点(Node对象)
          Node<K,V> p = map.replacementNode(q, null);
          //下面这段代码是单链表赋值
          if (tl == null)
               hd = p;
          else
               tl.next = p;
          tl = p;
     }
     //返回首个节点
     return hd;
}

Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
     //注意,此处是重新创建node对象
     return new Node<>(p.hash, p.key, p.value, next);
}
复制代码
  • 将红黑树转为单链表其实就是根据红黑树的首个元素的下标链接元素

2.3.2.treeify(tab)

接着我们分析源码。

	final void treeify(Node<K,V>[] tab) {
        	//定义根节点
            TreeNode<K,V> root = null;
        	//通过next节点进行迭代
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                //next节点指针指向
                next = (TreeNode<K,V>)x.next;
                //设置当前节点的左右为null
                x.left = x.right = null;
                //首个节点处理
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    //获取当前迭代节点的对应的key和hash以及Class
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    //从root几点开始循环,此循环只能从内部跳出
                    for (TreeNode<K,V> p = root;;) {
                        //dir为左右标识
                        //ph为当前节点的hash
                        //pk为当前节点的key
                        int dir, ph;
                        K pk = p.key;
                        //如果当前节点的hash大于迭代节点的hash
                        if ((ph = p.hash) > h)
                            //表示当前链表的节点会放置到当前节点的左侧
                            dir = -1;
                        else if (ph < h)
                            //表示当前链表的节点会放置到当前节点的右侧
                            dir = 1;
                        
                        //如果当前节点和迭代节点的key的hash值相等,则进入如下判断
                        //如果当前链表节点的key实现了comparable接口,并且当前树节点和链表节点是相同Class的实例,那么通过comparable的方式再比较两者
                        //如果还是相等,最后再通过tieBreakOrder比较一次
                        else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0))
                            dir = tieBreakOrder(k, pk);
					  //保存当前节点
                        TreeNode<K,V> xp = p;
                        //dir小于等于0,循环到的节点则在当前树节点的左侧
                        //dir大于0,循环到的节点则在当前树节点的右侧
                        //节点挂载之后还要进入平衡树阶段。
                        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);
        }
复制代码
  • treeify()函数内其实是通过节点的迭代对比hash和key(如果相等则通过comparable(如果还相等则用**tieBreakOrder()**方法判断)),并把结果赋值给dir。
  • 如果dir 小于等于0 : 当前链表节点一定放置在当前树节点的左侧,但不一定是该树节点的左孩子,也可能是左孩子的右孩子 或者 更深层次的节点
  • 如果dir 大于0 : 当前链表节点一定放置在当前树节点的右侧,但不一定是该树节点的右孩子,也可能是右孩子的左孩子 或者 更深层次的节点
  • 然后调用balanceInsertion()重新平衡红黑树
  • 把所有节点都迭代完毕,结果可能是经历了多次平衡操作,最终要通过moveRootToFront(tab, root)方法定位出根节点,并做处理

2.3.3.balanceInsertion()
解析此方法之前,首先介绍一下红黑树的特性:
复制代码
  • 节点是红色或黑色。
  • 根节点是黑色。
  • 每个叶节点(NIL节点,空节点)是黑色的。
  • 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)。
  • 从任一节点到其每个叶子的路径上包含的黑色节点数量都相同。

根据这5条特征,红黑树在节点插入时,经常会出现与上述规则不匹配的情况。则通过以下三种方式保持红黑树的平衡。

  • 变色

    因为特性2,所以在插入的过程中,如出现连续同色的节点,就会尝试变色为异色。

    为了重新符合红黑树的规则,尝试把红色节点变为黑色,或者把黑色节点变为红色

  • 左旋转

    这里沿用了网上非常形象的一张图

逆时针旋转红黑树的两个节点,使得右节点成为自己的父节点,自己变化为变化后的左节点

左旋转只影响旋转节点和自身的右子树的结构并挪向了左子树

  • 右旋转

顺时针旋转红黑树的两个节点,使得左节点成为自己的父节点自己变化为变化后的右节点

右旋转只影响旋转节点和自身的左子树的结构并挪向了右子树

左右旋转的代码具体实现下文会有解析

红黑树插入的方法其实是非常复杂的,这里先下一个结论,就是插入变化的所有情况有8种。我们下文会逐个解析。

	//此段代码较为复杂
	static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,TreeNode<K,V> x) {
            //将插入节点标红
            x.red = true;
            //xp:当前节点的父节点
            //xpp:当前节点的爷爷节点
            //xppl:当前节点的父亲节点的左兄弟节点(左叔叔节点)
            //xppr:当前节点的父亲节点的右兄弟节点(右叔叔节点)
            for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
                //1.如果父节点为空、当前节点为根节点,标黑并返回
                if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
                //2.如果父节点标黑,直接返回根节点
                else if (!xp.red || (xpp = xp.parent) == null)
                    return root;
                //3.如果父节点是爷爷节点的左孩子
                if (xp == (xppl = xpp.left)) {
                    //3.1如果右叔叔非空并标红
                    if ((xppr = xpp.right) != null && xppr.red) {
                        //右叔叔节点标黑
                        xppr.red = false;
                        //父节点标黑
                        xp.red = false;
                        //爷爷节点标红
                        xpp.red = true;
                        //将当前节点设置为爷爷节点,继续平衡操作
                        x = xpp;
                    }
                    //3.2如果右叔叔节点为空,或者为被标黑
                    else {
                        //3.2.1如果当前节点等于父节点的右节点
                        if (x == xp.right) {
                            //父节点左旋转
                            root = rotateLeft(root, x = xp);
                            //获取爷爷节点
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        //3.2.2如果父节点不为空
                        if (xp != null) {
                            //父节点标黑
                            xp.red = false;
                            //如果爷爷节点不为空
                            if (xpp != null) {
                                //爷爷节点标红
                                xpp.red = true;
                                //爷爷节点右旋转
                                root = rotateRight(root, xpp);
                            }
                        }
                    }
                }
                //4.如果父节点是爷爷节点的右孩子
                else {
                    //4.1如果左叔叔节点非空并且标红
                    if (xppl != null && xppl.red) {
                        //左叔叔节点标黑
                        xppl.red = false;
                        //父节点标黑
                        xp.red = false;
                        //爷爷节点标红
                        xpp.red = true;
                        //将当前节点设置为爷爷节点,继续平衡操作
                        x = xpp;
                    }
                    //4.2如果左叔叔节点空或者标黑
                    else {
                        //4.2.1如果当前节点是父节点的左孩子
                        if (x == xp.left) {
                            //对父节点做右旋转
                            root = rotateRight(root, x = xp);
                            //获取爷爷节点
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        //4.2.2如果父节点不为空
                        if (xp != null) {
                            //父节点标黑
                            xp.red = false;
                            //如果爷爷节点不为空
                            if (xpp != null) {
                                //爷爷节点标红
                                xpp.red = true;
                                //对爷爷节点做左旋转
                                root = rotateLeft(root, xpp);
                            }
                        }
                    }
                }
            }
        }
复制代码

根据分析,总结结构图如下:

根据结构图和源码解析,其实分支三和分支四的处理逻辑相近。接下来我们用图详解。

此图为3.2分支的推到过程,其实4.2分支就是3.2每步的取反。变色很简单就不画图了。

大家学习的时候要反复对比结构图和推理图

接下来我们解析左旋转和右旋转的方法。


2.3.3.1rotateLeft() 左旋转
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,TreeNode<K,V> p) {
            TreeNode<K,V> r, pp, rl;
            if (p != null && (r = p.right) != null) {
                //step1
                if ((rl = p.right = r.left) != null)
                    rl.parent = p;
                //step2
                if ((pp = r.parent = p.parent) == null)
                    (root = r).red = false;
                //step3
                else if (pp.left == p)
                    pp.left = r;
                //step4
                else
                    pp.right = r;
                //step5
                r.left = p;
                p.parent = r;
            }
            return root;
        }	
复制代码

这次我们直接上图,语言太难描述了


2.3.3.1 rotateRight() 右旋转
	static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,TreeNode<K,V> p) {
            TreeNode<K,V> l, pp, lr;
            if (p != null && (l = p.left) != null) {
                if ((lr = p.left = l.right) != null)
                    lr.parent = p;
                if ((pp = l.parent = p.parent) == null)
                    (root = l).red = false;
                else if (pp.right == p)
                    pp.right = l;
                else
                    pp.left = l;
                l.right = p;
                p.parent = l;
            }
            return root;
        }
复制代码

右旋转和上图逻辑同理,只不过是取反。

分类:
Android
标签: