浅谈Java8中的HashMap

“听过很多道理，却依然过不好这一生。” 这是电影《后会无期》里的一句经典台词。就像我看过很多HashMap的解析，却依然对很多概念模棱两可。因此决定自己动手，丰衣足食。

在Java7的基础上，Java8对HashMap进行了一些优化。其中最大的变化就在于当链表中的元素个数超过8个时，会将链表转换为红黑树结构，以降低对这部分数据进行查找时的时间开销。其示意图如下：

Java8 HashMap结构示意图

与这两种结构相对应，Java8中的HashMap引入了Node和TreeNode两个对象分别来表示链表结构和红黑树结构的节点。它们的数据结构如下。

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

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

接下来我们具体看一下HashMap中的主要属性和方法。

主要属性

// 哈希数组，首次使用时进行初始化，必要时进行扩容，长度只能是2的整数次幂
transient Node<K,V>[] table;

// 缓存的Entry
transient Set<Map.Entry<K,V>> entrySet;

// Map中的元素个数
transient int size;

// HashMap结构上被修改的次数，主要是指元素个数的变化或者进行了重新Hash。
transient int modCount;

// 阈值，超过阈值时将进行扩容
int threshold;

// 负载因子
final float loadFactor;

// 当桶中元素个数超过这个值时，需要使用红黑树节点替换链表节点
static final int TREEIFY_THRESHOLD = 8;

// 当桶中元素个数小于这个值时，就会把树形的桶元素 还原为链表结构，这个值应该小于TREEIFY_THRESHOLD
static final int UNTREEIFY_THRESHOLD = 6;

// 当哈希表中的容量大于这个值时，桶中的链表才进行树形化，否则会直接会扩容进行重新哈希
// 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;

构造方法

HashMap中有4个构造方法，其中带有容量和负载因子的构造方法最复杂，其它3个都很简单，这里就不再关注了。

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

// 这个方法返回的是不小于指定容量的2的整数次幂的最小值，最后这个值赋给了阈值，对的，是阈值！！！
// 我理解的应该是赋值给容量，然后结合负载因子计算出阈值。
// 在resize()方法中初始化时确实是这么做的，但是没明白为什么要绕这么大一个弯子
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;
}

put()方法

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// onlyIfAbsent用于标识当执行put()操作时，如果其中已经存在相同的key，否允许继续插入。
// true：只有当key不存在时才允许插入
// false: key存在时也允许插入
// evict目前还没搞明白o(╯□╰)o
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;

    // 首次put时，将会触发resize进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

    // 根据hash值找到对应的数组下标，如果此位置为空，则直接插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        // 走到这里，表明该位置已经有数据了
        Node<K,V> e; K k;

        // 如果该位置第一个元素的key与要插入元素的key相等，则覆盖旧值
        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) {
                // 构造Node节点，插入到链表最后
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);

                    // 如果插入后元素个数超过了TREEIFY_THRESHOLD(默认值为8)，则需要进行扩容或者是将链表转化为红黑树结构，具体逻辑后面在讲treeifyBin()时再展开
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }

                // 如果在该链表中找到了相等的key，同样覆盖旧值
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }

        // e != null，表明该链表中存在一个元素，它的key与要插入元素的key相等
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }

    // 插入了新元素，modCount加1
    ++modCount;

    // 如果超过了阈值，则需要扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

可以看到，put()方法的总体思路为：

• hash数组是否为空，为空则先调用resize()方法进行初始化
• 根据hash值找到对应的数组下标，如果对应节点为空，直接插入
• 对应节点第一个元素的key是否与待插入元素的key相等，相等则直接替换第一个元素
• 对应节点第一个元素的key是否与待插入元素的key不相等，且该节点是红黑树，则调用红黑树的插入方法putTreeVal()
• 对应节点第一个元素的key是否与待插入元素的key不相等，且该节点是链表，如果链表中所有元素的key与待插入元素的key都不相等，则将该元素直接加到链表最后，否则覆盖相同key的值
• 插入新元素后，如果hash数组长度超过阈值，则需要调用resize()方法进行扩容

初始化和扩容都是通过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
    }
    // 把容量设置成阈值，是因为使用带有容量的构造方法初始化时，利用tableSizeFor()计算出来的容量值赋值给了阈值。
    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;

    // 初始化新数组，初始化时，oldTab == null，到这里就直接返回了
    @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;
                        // 扩容时需要生成两个链表，将原来在一个链表里的元素分到两个链表里去，
                        // 这里采用了一种非常巧妙的方式，即用key的哈希值跟旧的容量做与运算，
                        // 也就是说，如果旧的容量是2的N次幂，则根据key的哈希值的第N位是0还是1来分为两个链表。
                        // 为0的放在低位链表，为1的放在高位链表
                        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;
                    }
                    // 高位链表移动oldCap位
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

resize()方法的总体思路为：

• 数组容量是否达到了上限，没有则设置新的容量和阈值
• 数组是否进行了初始化，没有则进行初始化，然后直接返回
• 扩容时，如果节点是红黑树，则调用红黑树的扩容方法；如果节点是链表，则生成两个新链表进行数据迁移，把key的哈希值第N位是0节点放在低位链表，是1的节点放在高位链表

在整个迁移过程中，低位链表和高位链表中元素的相对顺序与扩容之前是相同的，这也是JDK1.8与JDK1.7的区别之一。因此这样导致了在1.7中可能引发环形链表导致死循环的问题在1.8中不复存在。那么这是否意味着1.8中的HashMap就是线程安全的呢？当然不是的，在1.8中，Hashmap的线程不安全主要是因为在并发执行put操作的时候，在下面这个位置可能会出现数据丢失的情况。

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;

    // 根据hash值找到对应的数组下标，如果此位置为空，则直接插入
    // 这里如果存在并发情况，由于是直接插入，因此可能会出现一个线程的数据被另外一个线程覆盖的情况，从而导致数据丢失。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
...

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;
    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;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}