HashMap源码浅析（一）：树化

疑问：
1)解决hash冲突的几种方式   
2)Map中的Entry根据key和value向上和向上排序  
HashMap是基于数组和链表来实现的,在查询和插入、删除上都有相当快的速度,
因为它是通过计算散列码来决定存储位置的。
HashMap中主要是通过key的hashcode来计算hash值的,如果存储的对象多了,
可能会出现相同的hashcode值,也就是所谓的hash冲突,解决hash冲突的办法有很多,
而hashMap则是通过链表来解决的。
hashmap中hash值不同的放入到数组中,称为hash数组,数组中的元素是链表的头节点;
hash相同的则插入到对应的链表的尾部

具体的结构,jdk1.8中,hashmap内部维护了一个Node的实体类,用于储存节点的信息,
包括key、hash值、value值以及指向下一个节点的引用next。
这个Node类继承于Map的Enrty的内部类,所以具有获取key,value,以及替换旧值的
作用,此外Map中的Entry还可以进行比对key以及value的比较。
hash数组则是一个Node数组,数组每一个元素都是Node链表的头结点,

特点：
1)插入和删除移动速度都很快
2)线程不安全 
3)数组长度达到64 链表长度达到8 就会转变为红黑树

HashMap是一个散列表,通过键值对的形式对元素进行存储,HashMap是线程不安全的,key-value都是可以为null的,但是元素是无序的,影响HashMap的主要两个参数是初始容量.加载因子
容量是哈希表中桶的数量,加载因子是哈希表在其容量自动增加之前可以达到的一种尺度,当哈希表中的桶数量超出了加载因子与当前容量的乘积时,就会进行扩容操作
HashMap整体是一个数组,不过数组的每一项都是由一个单链表组成,下标由hash值构成,在jdk8中,当数组长度达到64并且单链表的长度达到8之后,链表会转化成红黑树的结构,这时的HashMap则变成了数组+红黑树的结构

HashMap继承于Map,我们先从HashMap的Node开始,static class Node implements Map.Entry,Node实现了Map中的Entry接口,我们来看Entry中的抽象方法

getKey()获取当前节点的key值
getValue() 获取当前节点的Value
setValue()为当前节点的value值进行赋值操作
comparingByKey() 通过keyzhi比较当前节点与指定节点的大小,用来进行排序操作
comparingByValue() 通过value值比较当前节点与指定节点的大小,用来进行排序操作
comparingByKey(Comparator cmp) 使用自定义的比较器通过key值来比较当前节点与指定节点的大小用来进行排序操作
comparingByValue(Comparator cmp)使用自定义的比较器通过value值来比较当前节点与指定节点的大小用来进行排序操作

Node中有几个成员变量和重写的方法

final int hash 不可变常量 hash
final K key 不可变常量key
V value 变量value
Node next 变量下一节点

构造器

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

jdk1.8之后,HashMap引入了红黑树,所以这里同样需要树节点TreeNode

static final class TreeNode extends LinkedHashMap.LinkedHashMapEntry

static class LinkedHashMapEntry extends HashMap.Node

TreeNode最终继承于HashMap.Node,且为final类型不可被继承.

TreeNode parent 父节点
TreeNode left 左子叶节点
TreeNode right 右子叶节点
TreeNode prev前一节点

下面我们来看HashMap中的方法

构造器

    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);
    }

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

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

    public HashMap(Map m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

第一个构造器,入参为指定初始容量和加载因子,并计算扩容阀值threshold,默认为容量*加载因子即threshold = 16,当HashMap中的总元素数量达到这个阀值时,会通过resize()进行扩容操作
第二个构造器,入参为指定初十日容量,默认加载因子为0.75f
第三个构造器,只是设置了默认的加载因子
第四个构造器,入参为一个map集合,通过putMapEntries加入到当前集合中,并设置加载因子为默认值.

put

    // table 为储存Node的数组,即HashMap真正存储元素的数组
    transient Node[] table;
    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[] tab; Node p; int n, i;
        
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode)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;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

put()会直接调用putVal(),在putVal()中会,初始化几个变量,这里暂且不管,往下看判断体, 将数组table赋值给tab 并检测当前数组是否是空数组如果当前数组是空数组的话,则通过扩容方法resize()获取一个数组,并计算数组的长度,赋值给n,

HashMap#resize():

    final Node[] resize() {
        Node[] 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[] newTab = (Node[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node 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;
                        }
                    }
                }
            }
        }
        return newTab;
    }

开始同样现将table赋值给oldTab,然后计算出当前数组的容量,获取到当前数组的扩容阀值,并初始化新数组的容量和扩容阀值。
第一个if判断语句,判断当前数组的容量是否大于0,在我们创建完HashMap对象之后,并没有直接的创建Node[],所以这里不会进入判断体,
然后进入else if中,当前数组的扩容阀值为16,会将当前的扩容阀值赋值给newCap作为新数组的总容量,
继续往下看下一个if,此时的newThr == 0,进入判断体,首先根据加载因子loadFactor和新数组容量newCap得出新数组的扩容阀值，然后在判断要不要使用这个扩容阀值:

static final int MAXIMUM_CAPACITY = 1 << 30;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
                      
newCap = 16
ft = 12
MAXIMUM_CAPACITY = 1 * 2^30
所以条件成立,newThr = ft = 12

因此到这里可以小结一下:这里的判断是为了计算出新数组的容量和扩容阀值
继续往下看,将得到的扩容阀值赋值给原扩容阀值threshold,并创建一个容量为newCap的Node[],将新数组赋值给原始数组table,前面有说oldTab = null,所以判断体就不会进入了,直接返回newTab;

回到putVal(),我们通过resize()获取到了一个新的数组,并获取到其长度赋值给n,n = 12;
继续下一个判断,通过n-1与hash的与运算获取到一个数组的下标值,因为此时的数组是空数组,所以此时的该下标所对应的node节点为null,所以会进入到判断体.根据hash、key、value创建一个新的node节点,并放入当前数组的该下标中,最后修改次数+1,元素数量size+1,并判断是否大于扩容阀值,如果大于则通过resize()进行扩容操作
倘若这里需要进行扩容操作,我们进去看看了,

        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
        }

首先这个判断条件是成立的,在进入羡慕的判断条件,如果当前数组的容量大于等于MAXIMUM_CAPACITY = 2 ^ 30,那么进入判断,很显然,这个条件很难达成,直接进入else if,oldCap = 16,左移一位是32,newCap = 32,默认数组容量DEFAULT_INITIAL_CAPACITY = 16,所以判断成立,oldThr = 12,左移一位是newThr = 24,得到新数组的扩容阀值,然后创建一个新的Node[],并将newCap = 32作为新数组的长度,将新创建的数组赋值给table = newTable,
进入下一个判断语句,此时的oldTable不为空,所以进入判断体,这个判断体主要是将原始数组的数据遍历加入到新建数组中,

if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node loHead = null, loTail = null;
                        Node hiHead = null, hiTail = null;
                        Node 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;
                        }
                    }
                }
            }
        }

首先是进入一个for循环,遍历数组中的每一个节点桶(主要是节点桶的头结点),如果当前节点桶不为null,则取出头结点,并将原始数组的当前节点桶设置为null,如果节点桶中只有一个头结点,即头结点无下一节点,根据头结点的hash值和容量得到一个新的节点下标,并将此头结点加入到此下标中;如果头结点有下一节点,这里暂且不考虑红黑树的情况,那么进入else里面
else中是一个while循环,因为每一个节点桶都是一个单链表,所以这里的while循环主要是遍历原始数组中的一个桶的单链表,循环加入到新建数组中,关于扩容下标的计算从网上找到了一篇介绍,如果感兴趣可以看一下https://www.cnblogs.com/shianliang/p/9204942.html

回到puVal(),此时到这里第一条数据算是添加完成了,开篇又说,HashMap在jdk1.8中加入了红黑树,我们来看看树化的条件和过程,同样还是putVal()：

            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;
                }
            }

在添加数据的时候,如果要添加的数据所对应的下标在数组中有数据,此时就需要将此数据添加到链表/树中,就会进入到上面的else语句中,首先拿到数组中此下标对应的头结点e,然后开启一个死循环遍历链表(如果此时桶中的是树,则不会进入这个else,下面会说到往树中添加数据的过程),拿到头结点e之后,开始遍历头结点所在的单链表,知道遍历到链表的尾部,然后通过newNode创建一个新的节点,加入到链表的尾部,然后判断链表的长度是否大于等于 8,即binCount >= TREEIFY_THRESHOLD - 1 = 7,(因为遍历链表是从0开始的,所以最终是链表的长度不得大于等于8)如果大于等于的话,则开始通过treeifyBin()开始树化。

static final int MIN_TREEIFY_CAPACITY = 64;

    final void treeifyBin(Node[] tab, int hash) {
        int n, index; Node e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode hd = null, tl = null;
            do {
                TreeNode 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);
        }
    }

首先得到数组的长度,如果数组的长度小于MIN_TREEIFY_CAPACITY,那么就直接进行扩容操作,而不是进行树化,所以这里我们可以知道

扩容的条件有两个: 1)数组的长度达到了扩容阀值,2)桶中的链表长度达到了8,并且数组的长度小于64
树化的条件是：桶中单链表的长度达到了8,并且数组的长度大于等于64

我们来看else if,这里面同样是一个while循环,判读语句中拿到链表的头结点,因为树节点TreeNode继承于HashMap.Node,所以这里边先将链表的头结点e转化为一个树节点p,然后开始遍历头结点,开始给各个树节点添加前后节点的引用(看起来更像是一样双链表),桶内的树节点全部添加为前后引用之后,真正的树化就要开始了：

            if ((tab[index] = hd) != null)
                hd.treeify(tab);
                
                
                
        final void treeify(Node[] tab) {
            TreeNode root = null;
            for (TreeNode x = this, next; x != null; x = next) {
                next = (TreeNode)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 p = root;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);

                        TreeNode 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);
        }

treeify的入参为需要被树化的链表的头结点所转换为的树节点,然后开始一个for循环,条件为x != null,next则为每次循环x的下一节点引用
先说一下红黑树的五个性质:

每个结点要么是红的，要么是黑的。
根结点是黑的。
每个叶结点，即空结点（NIL）是黑的。
父节点和子节点都不能同时是红色的，即：不能有两个连续的红色节点
对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。
关于红黑树可以看我这篇文章 TreeMap 源码分析
继续往下说,循环内:
首先得到x的下一节点并赋值给next,并初始化当前节点x的左右子叶节点,第一遍循环root节点肯定是为空的,所以将x节点设置为根节点root,并将其父节点设置为null,颜色设置为黑色,这是第一次循环,第二次循环,进入到了else语句中,首先获取到当前节点的key值和hash值，下面是一个死循环：
在死循环内首先得到根节点,并将根节点的hash值和当前节点的hash值做对比,如果比根节点大则在根节点的右子树上,比根节点小则在左子树上,红黑树中,左子树总比右子树要小,然后依次遍历-对比判断最后将当前节点放到合适的树节点的左右子树中。

                        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;
                        }

上面的代码正如我们所说的,遍历整个红黑树并将当前节点放入到指定合适的左右子树中,因为我们还没有为当且插入的节点进行着色操作,所以需要通过balanceInsertion进行着色,基于红黑树的五个特性我们在插入一个树节点并且为其着色之后,可能需要重新调整红黑树,为什么呢,其他的不说,开始我们自发的将单链表的头结点设置为了根节点,如果单链表的其他节点均小于头结点,那么在树中的表现为,根节点的左子树很深,而右子树则没有,红黑树是一种平衡树,根据第五条特性可以看出,所以需要对红黑树进行调整,同样需要balanceInsertion来操作。

        static  TreeNode balanceInsertion(TreeNode root,
                                                    TreeNode x) {
            x.red = true;
            for (TreeNode xp, xpp, xppl, xppr;;) {
                if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
                else if (!xp.red || (xpp = xp.parent) == null)
                    return root;
                if (xp == (xppl = xpp.left)) {
                    if ((xppr = xpp.right) != null && xppr.red) {
                        xppr.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    else {
                        if (x == xp.right) {
                            root = rotateLeft(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateRight(root, xpp);
                            }
                        }
                    }
                }
                else {
                    if (xppl != null && xppl.red) {
                        xppl.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    else {
                        if (x == xp.left) {
                            root = rotateRight(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateLeft(root, xpp);
                            }
                        }
                    }
                }
            }
        }

入参为根节点和当前节点,首先设置当前节点是红色,里面是一个for循环,先看循环中的第一个判读体

               if ((xp = x.parent) == null) {
                    x.red = false;
                    return x;
                }
                else if (!xp.red || (xpp = xp.parent) == null)
                    return root;

如果当前树节点的父子树节点为空,因为当前节点已在红黑树中,那么只有一种可能,当前节点是父节点,颜色着色为黑色,并返回当前节点,
如果当前节点的父节点是黑色,并当前节点的祖父节点为空,所以当前节点是根节点的子树节点,所以不需要调整红黑树,直接返回就行
所以上面的判断是祛除当前节点是根节点或者当前节点是根节点的子树节点的情况,如果根节点只有一个子树节点,那么此时的红黑树违反第五条特性,但是怎么调整都是这样,就会陷入一个死循环中,所以排除了这种情况.
通过上面的判断,可以知晓循环体中的变量的意义:

xp当前节点的父节点
xpp当前节点的父节点的父节点,即祖父节点
xppl当前节点的祖父节点的左子树节点即当前节点的叔父节点
xppr 当前节点的祖父节点的右子树节点即当前节点的叔父节点

接着往下看

                if (xp == (xppl = xpp.left)) {
                    if ((xppr = xpp.right) != null && xppr.red) {
                        xppr.red = false;
                        xp.red = false;
                        xpp.red = true;
                        x = xpp;
                    }
                    else {
                        if (x == xp.right) {
                            root = rotateLeft(root, x = xp);
                            xpp = (xp = x.parent) == null ? null : xp.parent;
                        }
                        if (xp != null) {
                            xp.red = false;
                            if (xpp != null) {
                                xpp.red = true;
                                root = rotateRight(root, xpp);
                            }
                        }
                    }
                }

首先要确定一点就是,能进入当前循环的都是父节点是红色的,如果是黑色的,在上个判断体中的else中就拦截掉了,看当前的判断判断条件是如果xp是xpp的左子树节点,即xppl,然后进入下一个判断
如果当前节点的叔父节点xppr不为空,并且颜色为红色,那么就进行如下设置:叔父节点xppr设置为黑色,xp设置为黑色,xpp设置为红色,然后将祖父节点xpp设置为当前节点,进行下一次的遍历循环,开始判断祖父节点变为红色之后是否合乎红黑树的特性,如果祖父节点的父节点是黑色的话,那就没有异常,直接返回根节点即可,如果祖父节点的父节点是红色,因为祖父节点也是红色的,违反了第四个特性,需要对红黑树进行调整,下面就涉及到了红黑树的左右旋的操作,限于篇幅这里就不过多介绍了,

如果xp == xppl,xp.color = red

如果xppr.color == red,那么xpp.color != red, 则设置xpp.color == red并且xppl,xppr != red;
如果xppr.color != red

如果当前节点为父节点的右子树节点,左旋父节点,使父节点位于当前节点的左子树上,然后将父节点作为当前节点进行如下处理：
设置当前节点的父节点的颜色为黑色,祖父节点为红色,右旋祖父节点

如果当前节点为父节点的左子树节点:
设置当前节点的父节点的颜色为黑色,祖父节点为红色,右旋祖父节点

如果父节点位于祖父节点的右子树上,道理是一样的.

回到treeify,树化完成之后还有最后一步moveRootToFront,因为HashMap中的红黑树是与双链表糅合在一起的,具体表现为,数组table获取当前下标的节点,是链表的头结点,单不一定是树的根节点,因此需要将树的根节点与链表的头结点设置为同一个

        static  void moveRootToFront(Node[] tab, TreeNode root) {
            int n;
            if (root != null && tab != null && (n = tab.length) > 0) {
                int index = (n - 1) & root.hash;
                TreeNode first = (TreeNode)tab[index];
                if (root != first) {
                    Node rn;
                    tab[index] = root;
                    TreeNode rp = root.prev;
                    if ((rn = root.next) != null)
                        ((TreeNode)rn).prev = rp;
                    if (rp != null)
                        rp.next = rn;
                    if (first != null)
                        first.prev = root;
                    root.next = first;
                    root.prev = null;
                }
                assert checkInvariants(root);
            }
        }

代码很简单我就不细说了,大致的说一下,首先从数组table中获取到当前下标的节点,即头结点,如果头结点与root节点不相同,则需要将root节点设置为头结点,首先将头结点的前后节点取出来,并使这两个节点相互关联,然后将根节点的next指针指向原先的头结点,原先头结点的prev指针指向根节点,并设置根节点的prev指针指向空,最终使根节点变成了头结点
到这里树化就完成了,虽然有点烂尾,具体有关红黑树的可以去看TreeMap 源码分析
树化完成之后,如果我们想要往树中添加一个节点的话,同样需要通过putVal来添加,其中有这么一条判断语句

else if (p instanceof TreeNode)
    e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);

其中p为根节点,插入过程中会循环遍历比较插入节点的hash值和遍历到的节点的hash值,然后插入到树中,插入之后,会检查树的平衡性,可能需要调整树的结构

回到putVal()，上面说了将元素添加到红黑树的过程,如果此时的数组桶中的是单链表那么：

                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;
                }

会通过for循环得到尾节点,将新建的节点添加到尾节点即可。
此外还有一种情况就是,如果当前节点对应key值在链表中存在,那么会走如下的判断:

            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

取出当前key对应原始value值，然后将传入的value值放入到里面,然后调用了afterNodeAccess(),最后返回了原始元素值,afterNodeAccess()在HashMap中是一个空实现,具体的实现在LinkedHashMap中,这里不再多说,我会在LinkedHashMap中说到.

HashMap源码浅析（一）：树化

构造器

你可能感兴趣的:(HashMap源码浅析（一）：树化)