概述
JDK 1.8对HashMap进行了比较大的优化,底层实现由之前的“数组+链表”改为“数组+链表+红黑树”,本文就HashMap的几个常用的重要方法和JDK 1.8之前的死循环问题展开学习讨论。JDK 1.8的HashMap的数据结构如下图所示,当链表节点较少时仍然是以链表存在,当链表节点较多时(大于8)会转为红黑树。
本文地址:http://blog.csdn.net/v123411739/article/details/78996181
几个点:
先了解以下几个点,有利于更好的理解HashMap的源码和阅读本文。
- 头节点指的是table表上索引位置的节点,也就是链表的头节点。
- 根结点(root节点)指的是红黑树最上面的那个节点,也就是没有父节点的节点。
- 红黑树的根结点不一定是索引位置的头结点。
- 转为红黑树节点后,链表的结构还存在,通过next属性维持,红黑树节点在进行操作时都会维护链表的结构,并不是转为红黑树节点,链表结构就不存在了。
- 在红黑树上,叶子节点也可能有next节点,因为红黑树的结构跟链表的结构是互不影响的,不会因为是叶子节点就说该节点已经没有next节点。
- 源码中一些变量定义:如果定义了一个节点p,则pl为p的左节点,pr为p的右节点,pp为p的父节点,ph为p的hash值,pk为p的key值,kc为key的类等等。源码中很喜欢在if/for等语句中进行赋值并判断,请注意。
- 链表中移除一个节点只需如下图操作,其他操作同理。
- 红黑树在维护链表结构时,移除一个节点只需如下图操作(红黑树中增加了一个prev属性),其他操作同理。注:此处只是红黑树维护链表结构的操作,红黑树还需要单独进行红黑树的移除或者其他操作。
- 源码中进行红黑树的查找时,会反复用到以下两条规则:1)如果目标节点的hash值小于p节点的hash值,则向p节点的左边遍历;否则向p节点的右边遍历。2)如果目标节点的key值小于p节点的key值,则向p节点的左边遍历;否则向p节点的右边遍历。这两条规则是利用了红黑树的特性(左节点<根结点<右节点)。
- 源码中进行红黑树的查找时,会用dir(direction)来表示向左还是向右查找,dir存储的值是目标节点的hash/key与p节点的hash/key的比较结果。
基本属性
- /**
- * The default initial capacity - MUST be a power of two.
- */
- static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认容量16
- /**
- * The maximum capacity, used if a higher value is implicitly specified
- * by either of the constructors with arguments.
- * MUST be a power of two <= 1<<30.
- */
- static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量
- /**
- * The load factor used when none specified in constructor.
- */
- static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认负载因子0.75
- /**
- * The bin count threshold for using a tree rather than list for a
- * bin. Bins are converted to trees when adding an element to a
- * bin with at least this many nodes. The value must be greater
- * than 2 and should be at least 8 to mesh with assumptions in
- * tree removal about conversion back to plain bins upon
- * shrinkage.
- */
- static final int TREEIFY_THRESHOLD = 8; // 链表节点转换红黑树节点的阈值, 9个节点转
- /**
- * The bin count threshold for untreeifying a (split) bin during a
- * resize operation. Should be less than TREEIFY_THRESHOLD, and at
- * most 6 to mesh with shrinkage detection under removal.
- */
- static final int UNTREEIFY_THRESHOLD = 6; // 红黑树节点转换链表节点的阈值, 6个节点转
- /**
- * The smallest table capacity for which bins may be treeified.
- * (Otherwise the table is resized if too many nodes in a bin.)
- * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
- * between resizing and treeification thresholds.
- */
- static final int MIN_TREEIFY_CAPACITY = 64; // 转红黑树时, table的最小长度
- /**
- * Basic hash bin node, used for most entries. (See below for
- * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
- */
- static class Node<K,V> implements Map.Entry<K,V> { // 基本hash节点, 继承自Entry
- final int hash;
- final K key;
- 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() {
- return Objects.hashCode(key) ^ Objects.hashCode(value);
- }
- public final V setValue(V newValue) {
- V oldValue = value;
- value = newValue;
- return oldValue;
- }
- public final boolean equals(Object o) {
- if (o == this)
- return true;
- if (o instanceof Map.Entry) {
- Map.Entry<?,?> e = (Map.Entry<?,?>)o;
- if (Objects.equals(key, e.getKey()) &&
- Objects.equals(value, e.getValue()))
- return true;
- }
- return false;
- }
- }
- /**
- * Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
- * extends Node) so can be used as extension of either regular or
- * linked node.
- */
- 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;
- TreeNode(int hash, K key, V val, Node<K,V> next) {
- super(hash, key, val, next);
- }
- // ...
- }
定位哈希桶数组索引位置
不管增加、删除、查找键值对,定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是“数组+链表+红黑树”的结合,所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些,尽量使得每个位置上的元素数量只有一个,那么当我们用hash算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,不用遍历链表/红黑树,大大优化了查询的效率。HashMap定位数组索引位置,直接决定了hash方法的离散性能。下面是定位哈希桶数组的源码:
- // 代码1
- static final int hash(Object key) { // 计算key的hash值
- int h;
- // 1.先拿到key的hashCode值; 2.将hashCode的高16位参与运算
- return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
- }
- // 代码2
- int n = tab.length;
- // 将(tab.length - 1) 与 hash值进行&运算
- int index = (n - 1) & hash;
整个过程本质上就是三步:
- 拿到key的hashCode值
- 将hashCode的高位参与运算,重新计算hash值
- 将计算出来的hash值与(table.length - 1)进行&运算
方法解读:
对于任意给定的对象,只要它的hashCode()返回值相同,那么计算得到的hash值总是相同的。我们首先想到的就是把hash值对table长度取模运算,这样一来,元素的分布相对来说是比较均匀的。
但是模运算消耗还是比较大的,我们知道计算机比较快的运算为位运算,因此JDK团队对取模运算进行了优化,使用上面代码2的位与运算来代替模运算。这个方法非常巧妙,它通过 “(table.length -1) & h” 来得到该对象的索引位置,这个优化是基于以下公式:x mod 2^n = x & (2^n - 1)。我们知道HashMap底层数组的长度总是2的n次方,并且取模运算为“h mod table.length”,对应上面的公式,可以得到该运算等同于“h & (table.length - 1)”。这是HashMap在速度上的优化,因为&比%具有更高的效率。
在JDK1.8的实现中,还优化了高位运算的算法,将hashCode的高16位与hashCode进行异或运算,主要是为了在table的length较小的时候,让高位也参与运算,并且不会有太大的开销。
下图是一个简单的例子,table长度为16:
get方法
- public V get(Object key) {
- Node<K,V> e;
- return (e = getNode(hash(key), key)) == null ? null : e.value;
- }
- final Node<K,V> getNode(int hash, Object key) {
- Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
- // table不为空 && table长度大于0 && table索引位置(根据hash值计算出)不为空
- if ((tab = table) != null && (n = tab.length) > 0 &&
- (first = tab[(n - 1) & hash]) != null) {
- if (first.hash == hash && // always check first node
- ((k = first.key) == key || (key != null && key.equals(k))))
- return first; // first的key等于传入的key则返回first对象
- if ((e = first.next) != null) { // 向下遍历
- if (first instanceof TreeNode) // 判断是否为TreeNode
- // 如果是红黑树节点,则调用红黑树的查找目标节点方法getTreeNode
- return ((TreeNode<K,V>)first).getTreeNode(hash, key);
- // 走到这代表节点为链表节点
- do { // 向下遍历链表, 直至找到节点的key和传入的key相等时,返回该节点
- if (e.hash == hash &&
- ((k = e.key) == key || (key != null && key.equals(k))))
- return e;
- } while ((e = e.next) != null);
- }
- }
- return null; // 找不到符合的返回空
- }
- 先对table进行校验,校验是否为空,length是否大于0
- 使用table.length - 1和hash值进行位与运算,得出在table上的索引位置,将该索引位置的节点赋值给first节点,校验该索引位置是否为空
- 检查first节点的hash值和key是否和入参的一样,如果一样则first即为目标节点,直接返回first节点
- 如果first的next节点不为空则继续遍历
- 如果first节点为TreeNode,则调用getTreeNode方法(见下文代码块1)查找目标节点
- 如果first节点不为TreeNode,则调用普通的遍历链表方法查找目标节点
- 如果查找不到目标节点则返回空
代码块1:getTreeNode方法
- final TreeNode<K,V> getTreeNode(int h, Object k) {
- // 使用根结点调用find方法
- return ((parent != null) ? root() : this).find(h, k, null);
- }
- 找到调用此方法的节点的树的根节点
- 使用该树的根节点调用find方法(见下文代码块2)
代码块2:find方法
- /**
- * 从调用此方法的结点开始查找, 通过hash值和key找到对应的节点
- * 此处是红黑树的遍历, 红黑树是特殊的自平衡二叉查找树
- * 平衡二叉查找树的特点:左节点<根节点<右节点
- */
- final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
- TreeNode<K,V> p = this; // this为调用此方法的节点
- do {
- int ph, dir; K pk;
- TreeNode<K,V> pl = p.left, pr = p.right, q;
- if ((ph = p.hash) > h) // 传入的hash值小于p节点的hash值, 则往p节点的左边遍历
- p = pl; // p赋值为p节点的左节点
- else if (ph < h) // 传入的hash值大于p节点的hash值, 则往p节点的右边遍历
- p = pr; // p赋值为p节点的右节点
- // 传入的hash值和key值等于p节点的hash值和key值,则p节点为目标节点,返回p节点
- else if ((pk = p.key) == k || (k != null && k.equals(pk)))
- return p;
- else if (pl == null) // p节点的左节点为空则将向右遍历
- p = pr;
- else if (pr == null) // p节点的右节点为空则向左遍历
- p = pl;
- else if ((kc != null ||
- // 如果传入的key(k)所属的类实现了Comparable接口,则将传入的key跟p节点的key比较
- (kc = comparableClassFor(k)) != null) && // 此行不为空代表k实现了Comparable
- (dir = compareComparables(kc, k, pk)) != 0)//k<pk则dir<0, k>pk则dir>0
- p = (dir < 0) ? pl : pr; // k < pk则向左遍历(p赋值为p的左节点), 否则向右遍历
- // 代码走到此处, 代表key所属类没有实现Comparable, 直接指定向p的右边遍历
- else if ((q = pr.find(h, k, kc)) != null)
- return q;
- else// 代码走到此处代表上一个向右遍历(pr.find(h, k, kc))为空, 因此直接向左遍历
- p = pl;
- } while (p != null);
- return null;
- }
- 将p节点赋值为调用此方法的节点
- 如果传入的hash值小于p节点的hash值,则往p节点的左边遍历
- 如果传入的hash值大于p节点的hash值,则往p节点的右边遍历
- 如果传入的hash值等于p节点的hash值,并且传入的key值跟p节点的key值相等, 则该p节点即为目标节点,返回p节点
- 如果p的左节点为空则向右遍历,反之如果p的右节点为空则向左遍历
- 如果传入的key(即代码中的参数变量k)所属的类实现了Comparable接口(kc不为空,comparableClassFor方法见下文代码块3),则将传入的key跟p节点的key进行比较(kc实现了Comparable接口,因此通过kc的比较方法进行比较),并将比较结果赋值给dir,如果dir<0则代表k<pk,则向p节点的左边遍历(pl);否则,向p节点的右边遍历(pr)。
- 代码走到此处,代表key所属类没有实现Comparable,因此直接指定向p的右边遍历,如果能找到目标节点则返回
- 代码走到此处代表与第7点向右遍历没有找到目标节点,因此直接向左边遍历
- 以上都找不到目标节点则返回空
代码块3:comparableClassFor方法
- /**
- * Returns x's Class if it is of the form "class C implements
- * Comparable<C>", else null.
- */
- static Class<?> comparableClassFor(Object x) {
- if (x instanceof Comparable) {
- Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
- if ((c = x.getClass()) == String.class) // bypass checks
- return c;
- if ((ts = c.getGenericInterfaces()) != null) {
- for (int i = 0; i < ts.length; ++i) {
- if (((t = ts[i]) instanceof ParameterizedType) &&
- ((p = (ParameterizedType)t).getRawType() ==
- Comparable.class) &&
- (as = p.getActualTypeArguments()) != null &&
- as.length == 1 && as[0] == c) // type arg is c
- return c;
- }
- }
- }
- return null;
- }
如果x实现了Comparable接口,则返回 x的Class。
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;
- // table是否为空或者length等于0, 如果是则调用resize方法进行初始化
- if ((tab = table) == null || (n = tab.length) == 0)
- n = (tab = resize()).length;
- // 通过hash值计算索引位置, 如果table表该索引位置节点为空则新增一个
- if ((p = tab[i = (n - 1) & hash]) == null)// 将索引位置的头节点赋值给p
- tab[i] = newNode(hash, key, value, null);
- else { // table表该索引位置不为空
- Node<K,V> e; K k;
- if (p.hash == hash && // 判断p节点的hash值和key值是否跟传入的hash值和key值相等
- ((k = p.key) == key || (key != null && key.equals(k))))
- e = p; // 如果相等, 则p节点即为要查找的目标节点,赋值给e
- // 判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法查找目标节点
- else if (p instanceof TreeNode)
- e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
- else { // 走到这代表p节点为普通链表节点
- for (int binCount = 0; ; ++binCount) { // 遍历此链表, binCount用于统计节点数
- if ((e = p.next) == null) { // p.next为空代表不存在目标节点则新增一个节点插入链表尾部
- p.next = newNode(hash, key, value, null);
- // 计算节点是否超过8个, 减一是因为循环是从p节点的下一个节点开始的
- if (binCount >= TREEIFY_THRESHOLD - 1)
- treeifyBin(tab, hash);// 如果超过8个,调用treeifyBin方法将该链表转换为红黑树
- break;
- }
- if (e.hash == hash && // e节点的hash值和key值都与传入的相等, 则e即为目标节点,跳出循环
- ((k = e.key) == key || (key != null && key.equals(k))))
- break;
- p = e; // 将p指向下一个节点
- }
- }
- // e不为空则代表根据传入的hash值和key值查找到了节点,将该节点的value覆盖,返回oldValue
- if (e != null) {
- V oldValue = e.value;
- if (!onlyIfAbsent || oldValue == null)
- e.value = value;
- afterNodeAccess(e); // 用于LinkedHashMap
- return oldValue;
- }
- }
- ++modCount;
- if (++size > threshold) // 插入节点后超过阈值则进行扩容
- resize();
- afterNodeInsertion(evict); // 用于LinkedHashMap
- return null;
- }
- 校验table是否为空或者length等于0,如果是则调用resize方法(见下文resize方法)进行初始化
- 通过hash值计算索引位置,将该索引位置的头节点赋值给p节点,如果该索引位置节点为空则使用传入的参数新增一个节点并放在该索引位置
- 判断p节点的key和hash值是否跟传入的相等,如果相等, 则p节点即为要查找的目标节点,将p节点赋值给e节点
- 如果p节点不是目标节点,则判断p节点是否为TreeNode,如果是则调用红黑树的putTreeVal方法(见下文代码块4)查找目标节点
- 走到这代表p节点为普通链表节点,则调用普通的链表方法进行查找,并定义变量binCount来统计该链表的节点数
- 如果p的next节点为空时,则代表找不到目标节点,则新增一个节点并插入链表尾部,并校验节点数是否超过8个,如果超过则调用treeifyBin方法(见下文代码块6)将链表节点转为红黑树节点
- 如果遍历的e节点存在hash值和key值都与传入的相同,则e节点即为目标节点,跳出循环
- 如果e节点不为空,则代表目标节点存在,使用传入的value覆盖该节点的value,并返回oldValue
- 如果插入节点后节点数超过阈值,则调用resize方法(见下文resize方法)进行扩容
代码块4:putTreeVal方法
- /**
- * Tree version of putVal.
- * 红黑树插入会同时维护原来的链表属性, 即原来的next属性
- */
- 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;;) { // 将根节点赋值给p, 开始遍历
- int dir, ph; K pk;
- if ((ph = p.hash) > h) // 如果传入的hash值小于p节点的hash值
- dir = -1; // 则将dir赋值为-1, 代表向p的左边查找树
- else if (ph < h) // 如果传入的hash值大于p节点的hash值,
- dir = 1; // 则将dir赋值为1, 代表向p的右边查找树
- // 如果传入的hash值和key值等于p节点的hash值和key值, 则p节点即为目标节点, 返回p节点
- else if ((pk = p.key) == k || (k != null && k.equals(pk)))
- return p;
- // 如果k所属的类没有实现Comparable接口 或者 k和p节点的key相等
- else if ((kc == null &&
- (kc = comparableClassFor(k)) == null) ||
- (dir = compareComparables(kc, k, pk)) == 0) {
- if (!searched) { // 第一次符合条件, 该方法只有第一次才执行
- TreeNode<K,V> q, ch;
- searched = true;
- // 从p节点的左节点和右节点分别调用find方法进行查找, 如果查找到目标节点则返回
- 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和p节点的key的大小, 用来决定向左还是向右查找
- dir = tieBreakOrder(k, pk); // dir<0则代表k<pk,则向p左边查找;反之亦然
- }
- TreeNode<K,V> xp = p; // xp赋值为x的父节点,中间变量,用于下面给x的父节点赋值
- // dir<=0则向p左边查找,否则向p右边查找,如果为null,则代表该位置即为x的目标位置
- if ((p = (dir <= 0) ? p.left : p.right) == null) {
- // 走进来代表已经找到x的位置,只需将x放到该位置即可
- Node<K,V> xpn = xp.next; // xp的next节点
- // 创建新的节点, 其中x的next节点为xpn, 即将x节点插入xp与xpn之间
- TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
- if (dir <= 0) // 如果时dir <= 0, 则代表x节点为xp的左节点
- xp.left = x;
- else // 如果时dir> 0, 则代表x节点为xp的右节点
- xp.right = x;
- xp.next = x; // 将xp的next节点设置为x
- x.parent = x.prev = xp; // 将x的parent和prev节点设置为xp
- // 如果xpn不为空,则将xpn的prev节点设置为x节点,与上文的x节点的next节点对应
- if (xpn != null)
- ((TreeNode<K,V>)xpn).prev = x;
- moveRootToFront(tab, balanceInsertion(root, x)); // 进行红黑树的插入平衡调整
- return null;
- }
- }
- }
- 查找当前红黑树的根结点,将根结点赋值给p节点,开始进行查找
- 如果传入的hash值小于p节点的hash值,将dir赋值为-1,代表向p的左边查找树
- 如果传入的hash值大于p节点的hash值, 将dir赋值为1,代表向p的右边查找树
- 如果传入的hash值等于p节点的hash值,并且传入的key值跟p节点的key值相等, 则该p节点即为目标节点,返回p节点
- 如果k所属的类没有实现Comparable接口,或者k和p节点的key使用compareTo方法比较相等:第一次会从p节点的左节点和右节点分别调用find方法(见上文代码块2)进行查找,如果查找到目标节点则返回;如果不是第一次或者调用find方法没有找到目标节点,则调用tieBreakOrder方法(见下文代码块5)比较k和p节点的key值的大小,以决定向树的左节点还是右节点查找。
- 如果dir <= 0则向左节点查找(p赋值为p.left,并进行下一次循环),否则向右节点查找,如果已经无法继续查找(p赋值后为null),则代表该位置即为x的目标位置,另外变量xp用来记录查找的最后一个节点,即下文新增的x节点的父节点。
- 以传入的hash、key、value参数和xp节点的next节点为参数,构建x节点(注意:xp节点在此处可能是叶子节点、没有左节点的节点、没有右节点的节点三种情况,即使它是叶子节点,它也可能有next节点,红黑树的结构跟链表的结构是互不影响的,不会因为某个节点是叶子节点就说它没有next节点,红黑树在进行操作时会同时维护红黑树结构和链表结构,next属性就是用来维护链表结构的),根据dir的值决定x决定放在xp节点的左节点还是右节点,将xp的next节点设为x,将x的parent和prev节点设为xp,如果原xp的next节点(xpn)不为空, 则将该节点的prev节点设置为x节点, 与上面的将x节点的next节点设置为xpn对应。
- 进行红黑树的插入平衡调整,见文末的解释2。
代码块5:tieBreakOrder方法
- // 用于不可比较或者hashCode相同时进行比较的方法, 只是一个一致的插入规则,用来维护重定位的等价性。
- 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;
- }
定义一套规则用于极端情况下比较两个参数的大小。
代码块6:treeifyBin方法
- final void treeifyBin(Node<K,V>[] tab, int hash) {
- int n, index; Node<K,V> e;
- // table为空或者table的长度小于64, 进行扩容
- if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
- resize();
- // 根据hash值计算索引值, 遍历该索引位置的链表
- 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) // tl为空代表为第一次循环
- hd = p; // 头结点
- else {
- p.prev = tl; // 当前节点的prev属性设为上一个节点
- tl.next = p; // 上一个节点的next属性设置为当前节点
- }
- tl = p; // tl赋值为p, 在下一次循环中作为上一个节点
- } while ((e = e.next) != null); // e指向下一个节点
- // 将table该索引位置赋值为新转的TreeNode的头节点
- if ((tab[index] = hd) != null)
- hd.treeify(tab); // 以头结点为根结点, 构建红黑树
- }
- }
- 校验table是否为空,如果长度小于64,则调用resize方法(见下文resize方法)进行扩容。
- 根据hash值计算索引值,将该索引位置的节点赋值给e节点,从e节点开始遍历该索引位置的链表。
- 调用replacementTreeNode方法(该方法就一行代码,直接返回一个新建的TreeNode)将链表节点转为红黑树节点,将头结点赋值给hd节点,每次遍历结束将p节点赋值给tl,用于在下一次循环中作为上一个节点进行一些链表的关联操作(p.prev = tl 和 tl.next = p)。
- 将table该索引位置赋值为新转的TreeNode的头节点hd,如果该节点不为空,则以hd为根结点,调用treeify方法(见下文代码块7)构建红黑树。
代码块7:treeify方法
- final void treeify(Node<K,V>[] tab) { // 构建红黑树
- TreeNode<K,V> root = null;
- for (TreeNode<K,V> x = this, next; x != null; x = next) {// this即为调用此方法的TreeNode
- next = (TreeNode<K,V>)x.next; // next赋值为x的下个节点
- x.left = x.right = null; // 将x的左右节点设置为空
- if (root == null) { // 如果还没有根结点, 则将x设置为根结点
- x.parent = null; // 根结点没有父节点
- x.red = false; // 根结点必须为黑色
- root = x; // 将x设置为根结点
- }
- else {
- K k = x.key; // k赋值为x的key
- int h = x.hash; // h赋值为x的hash值
- Class<?> kc = null;
- // 如果当前节点x不是根结点, 则从根节点开始查找属于该节点的位置
- for (TreeNode<K,V> p = root;;) {
- int dir, ph;
- K pk = p.key;
- if ((ph = p.hash) > h) // 如果x节点的hash值小于p节点的hash值
- dir = -1; // 则将dir赋值为-1, 代表向p的左边查找
- else if (ph < h) // 与上面相反, 如果x节点的hash值大于p节点的hash值
- dir = 1; // 则将dir赋值为1, 代表向p的右边查找
- // 走到这代表x的hash值和p的hash值相等,则比较key值
- else if ((kc == null && // 如果k没有实现Comparable接口 或者 x节点的key和p节点的key相等
- (kc = comparableClassFor(k)) == null) ||
- (dir = compareComparables(kc, k, pk)) == 0)
- // 使用定义的一套规则来比较x节点和p节点的大小,用来决定向左还是向右查找
- dir = tieBreakOrder(k, pk);
- TreeNode<K,V> xp = p; // xp赋值为x的父节点,中间变量用于下面给x的父节点赋值
- // dir<=0则向p左边查找,否则向p右边查找,如果为null,则代表该位置即为x的目标位置
- if ((p = (dir <= 0) ? p.left : p.right) == null) {
- x.parent = xp; // x的父节点即为最后一次遍历的p节点
- if (dir <= 0) // 如果时dir <= 0, 则代表x节点为父节点的左节点
- xp.left = x;
- else // 如果时dir > 0, 则代表x节点为父节点的右节点
- xp.right = x;
- // 进行红黑树的插入平衡(通过左旋、右旋和改变节点颜色来保证当前树符合红黑树的要求)
- root = balanceInsertion(root, x);
- break;
- }
- }
- }
- }
- moveRootToFront(tab, root); // 如果root节点不在table索引位置的头结点, 则将其调整为头结点
- }
- 从调用此方法的节点作为起点,开始进行遍历,并将此节点设为root节点,标记为黑色(x.red = false)。
- 如果当前节点不是根结点,则从根节点开始查找属于该节点的位置(该段代码跟之前的代码块2和代码块4的查找代码类似)。
- 如果x节点(将要插入红黑树的节点)的hash值小于p节点(当前遍历到的红黑树节点)的hash值,则向p节点的左边查找。
- 与3相反,如果x节点的hash值大于p节点的hash值,则向p节点的右边查找。
- 如果x的key没有实现Comparable接口,或者x节点的key和p节点的key相等,使用tieBreakOrder方法(见上文代码块5)来比较x节点和p节点的大小,以决定向左还是向右查找(dir <= 0向左,否则向右)。
- 如果dir <= 0则向左节点查找(p赋值为p.left,并进行下一次循环),否则向右节点查找,如果已经无法继续查找(p赋值后为null),则代表该位置即为x的目标位置,另外变量xp用来记录最后一个节点,即为下文新增的x节点的父节点。
- 将x的父节点设置为xp,根据dir的值决定x决定放在xp节点的左节点还是右节点,最后进行红黑树的插入平衡调整。
- 调用moveRootToFront方法(见下文代码块8)将root节点调整到索引位置的头结点。
代码块8:moveRootToFront方法
- /**
- * 如果当前索引位置的头节点不是root节点, 则将root的上一个节点和下一个节点进行关联,
- * 将root放到头节点的位置, 原头节点放在root的next节点上
- */
- static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
- int n;
- if (root != null && tab != null && (n = tab.length) > 0) {
- int index = (n - 1) & root.hash;
- TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
- if (root != first) { // 如果root节点不是该索引位置的头节点
- Node<K,V> rn;
- tab[index] = root; // 将该索引位置的头节点赋值为root节点
- TreeNode<K,V> rp = root.prev; // root节点的上一个节点
- // 如果root节点的下一个节点不为空,
- // 则将root节点的下一个节点的prev属性设置为root节点的上一个节点
- if ((rn = root.next) != null)