HashMap漫谈(2)

HashMap原理解析–JDK1.8

在前面的文章中，我介绍了JDK1.7中HashMap的实现原理，这篇文章中，我将继续介绍在JDK1.8中的实现机理，从JDK1.7到JDK1.8中，HashMap的实现中经历了较大的优化(当然源码也更长，看起来更复杂)，通过对数据结构的灵活应用，提高了这个稍微复杂数据结构的性能。本文中维持和上篇介绍JDK1.7中HashMap实现原理相同的结构来介绍，JDK1.8中HashMap的原理，包括基本数据结构，构造函数，put get方法等介绍。

基本数据结构

static class Node<K,V> implements Map.Entry<K,V> {
    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;
    }
}

JDK1.8中，使用了Node<K,V>作为基本数据结构，仔细来看这个数据结构，似乎是和JDK1.7中的Entry相同，只是换了个名字，这里我们暂时认为是一样的，那么HashMap的大体结构应该是这样的

构造方法

虽然jdk的版本变化，但是我们用户初始化的方式是没有变化的，仍然是通过这个方法实现

Map map = new HashMap()

所以使用的依然是无参的构造方法，在1.8中，这个方法的实现如下

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

这里，我们看到，这个构造函数并没有调用有参方法，只是对负载因数进行了设置。那么对于table的初始化就需要继续往下看。

put方法

接下来我们依照惯例来看一看put方法，该方法直接调用了putVal方法，具体实现如下：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, 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;
    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<K,V> 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<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;
                }
                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;
}

我们会发现，这个代码要比1.7中要复杂的多，我们就知道这个HashMap绝对没有那么简单。不过虽然复杂，但是总体的流程是和1.7相同的，总体步骤为：

1、当桶数组 table 为空时，通过扩容的方式初始化 table
2、查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
3、如果不存在，则将键值对链入链表中，并根据链表长度决定是否将链表转为红黑树
4、判断键值对数量是否大于阈值，大于的话则进行扩容操作

这里我把1.7的put流程放在这里进行比较：

1、如果bucket数组为空，调用inflateTable方法完成初始化；
2、判断待插入key是否为null：
 key == null成立，调用putForNullKey方法完成数据插入，由此可以看出，HashMap的key是可以为null的；
 key == null不成立，跳转到步骤3；
3、计算带插入key的hashCode；
4、根据hashCode按位与计算出所在bucket数组中的位置i；
5、遍历挂在bucket中位置i下的Entry链表，如果当前key已存在，更新它所对应的oldValue为value，并返回oldValue，否则，跳转到步骤6；
6、将key-value插入对应bucket中位置i下的Entry链表中，返回null。

我们把这个流程稍微整理一下，屏蔽一下细节的操作，也可以写成：

1、当桶数组 table 为空时，通过扩容的方式初始化 table
2、查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
3、如果不存在，则将键值对链入链表中
4、判断键值对数量是否大于阈值，大于的话则进行扩容操作

我们发现除了第3条的半句话，其他的内容都是相同的，这句话也正是JDK1.8中HashMap的实现变复杂的原因，在，JDK1.8中，为了增加查找的性能，在实现HashMap中，对于hash值相同的Node，当个数比较少时，还是采用原来的链表形式来存储，然而，当Node个数多个某个阈值时，会以红黑树的方式进行存储。这是一种比较特殊的平衡二叉树，在后面的文章中我可能会详细介绍这种数据结构，但是这篇文章的重点是介绍HashMap，我们给出一个连接来介绍红黑树，完全没概念的同学可以暂时先看这个，后面我完成对于这种数据结构的介绍后再替换链接 红黑树

。

我们详细来看这个方法，首先如果table为空，会调用resize方法创建table(稍后我介绍这个resize方法)，然后，像1.7一样，判断通过hash计算的下标对应的table的位置是不是有节点，没有的话直接创建，如果有的话，看这个节点是不是和带插入的key相同，如果相同，直接替换value，然后判断是以什么方法插入，可能是以红黑树插入节点的方法，也可能是链表。如果是链表，还要判断一下是不是到了上限，如果到了阈值，直接变成红黑树。最后这个if是为了如果是发生了替换，直接返回oldvalue。

简单介绍完了这个put方法，我们着重介绍里面的两个比较关键的方法，扩容方法resize以及将链表变红黑树的方法treeifyBin方法。

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) {
        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;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> 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<K,V>)e).split(this, newTab, j, oldCap);
                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;
                    }
                }
            }
        }
    }
    return newTab;
}

这个resize方法可能会在table为空或者现在容量要到达阈值时，我们现在的table还没有初始化，所以这个方法的oldTab=null，在这种状态下，我们可以看到走的是这条分支

else {               // zero initial threshold signifies using defaults
    newCap = DEFAULT_INITIAL_CAPACITY;
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}

这个逻辑我们其实是似曾相识的，这和1.7是相似的，其实包括后面的方法也是相同的，就是重新创建一个更大的Table，把原来的复制到这个table上。这里我想特别的提一下，如果用户自己设定了capacity，其实HashMap也会找到一个大于等于这个cap且为2的倍数的数量当成这个HashMap的容量，但是方法变了一下，实现方法如下：

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

我们以cap=15为例做了个例子，如图所示

回到这个方法，总体来说，这个方法的逻辑如下：

1、计算新桶数组的容量 newCap 和新阈值 newThr
2、根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的
3、将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组。

我们简单看一下这个拆解链表的过程，也就是这一段代码，对于红黑树的操作，我还是打算单独拉出一篇文章单独讲，所以这里先忽略，读完这篇文章后，只需要知道JDK1.8中有这么个操作就好

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

这里我们假设cap从8扩大到16，那么oldCap就应该是8，newCap就是16，假设有4个hash，35，27，19，43，遍历链表，分别计算hash & oldCap

那么通过计算可知：35 & 8 = 0;19 & 8 = 0;27 & 8 != 0;43 & 8 != 0

这样我们看lo应该是等于0的不等于0的是loIndex + oldCap的位置，最后可以转变为如下的图

至此我们就看完了resize的过程。

下面我们看一下treeifyBin方法的实现

treeifyBin

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

树化有两个条件会触发，分别为：

1、链表长度大于等于 TREEIFY_THRESHOLD
2、桶数组容量大于等于 MIN_TREEIFY_CAPACITY

这里我们看到最后从Node变为了TreeNode，通过调用replacementTreeNode方法，我们首先看一下TreeNode的结构定义