手撕Java类HashMap

本文分析的是 Java 8 中的 HashMap。

静下心来…

底层数据结构

数组+链表 任然是做为其最初的底层结构，但在 Java 8 中新增了 红黑树，在某种情况下，又将会转化为 数组+红黑树。

存储的元素为 Node<K,V>，它仍然为 Map.Entry<K,V>：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
}
// 省略了 get/set/equals 方法

当某部分节点由链表转换为红黑树时，节点将由普通节点变为树型节点：

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;
}
// 这里仅仅列出了成员，其涉及的方法比较多，可自行查阅源码

初始化

在调用构造函数时，仅仅初始化了 loadFactor 和 threshold，threshold 用于判断表什么时候扩容，它的值等于 (loadFactor * capacity )。 loadFactor 则表示在超过了表大小的多少重新进行扩容。注意，这时候表尚未初始化。

在调用 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;
        // 表是否需要初始化
        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;
            // 此次为插入重复元素操作
            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);
                        // 判断是否达到树化阈值（8）
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 1.树化该箱（当前数组元素）
                            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;
            }
        }
        // 并发计数加 1
        ++modCount;
        // 2. 是否需要扩容
        if (++size > threshold)
            resize();
        // 回调方法
        afterNodeInsertion(evict);
        return null;
    }

第一步所指的树化该箱（当前数组元素）不太好理解，其实指的是将数组元素的链表结构，调整为树结构（链表长度为 9）。

平常所说多为 链表长度为 8 时，开始转换为红黑树，这应该是指新节点插入前；但从源码来看，是先插入新的节点，后尝试树型化，所以描述为 “链表长度为 9 ，开始转换为红黑树 ” ，或许更准确。

再来看具体的树型化方法：

	final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 1.如果表大小小于 64 , 则进行扩容
        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 所述，当表大小小于 64 时，并不触发树型化该箱（指当前链表），也就是说，链表长度大于 8 时，底层并不一定会转换为红黑树；表的大小必须要达到要求的最小树型化值，即 64。

存取操作

上文对于 HashMap 的存其实分析的已经差不多了，下面看看它是如何取的：

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

不知道，各位有没有发现，这里的 key 并没有使用泛型，而直接使用的 Object ，反正以前，我是没有注意到。而且 HashMap 是允许 key 为 null 的，所以这里未做边界检查，当 key 为 null 时，hash 为 0。

如果该方法返回 null，那么对于允许 value 值为 null 的 Map ，并不能判断是否该 key 没有对应的值，或者是该 key 显示的映射了 null，但可以结合 containsKey 方法来做区分。

下面来看具体的 getNode 方法：

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

上面的逻辑比较简单，但值得一提的是，每次都会先比较第一个节点，不论底层是链表，还是红黑树。这里再分析下为什么 key 并没有使用泛型，底层其实并不关心这个 key 具体是什么对象，因为它只需要调用它的 equals 方法，知道 key 是否相等。但是，我仍然觉得，这可能使我无法在编译期更早地发现错误，个人拙见。

扩容

初始化以及扩容，都在 resize 方法中进行的。在进行扩容时，每个箱（数组元素所涉及的链表或者红黑树）中的元素必须保持相同的索引，或者以 2 的 幂（原表的大小）在新表中偏移。

计算新数组索引时，原始索引计算方式 hash & (cap - 1 ), 新的索引计算方式是 hash & (2 * cap - 1), 这里转换一下，其实新的索引要么等于原数组中的索引大小，要么等于 原数组中的索引大小加原数组cap。

例如，原始 cap 为 16（2 的 4 次幂，这里的 4 计为 n），新的 cap 则为 32（2 的 n+1 次幂）：

1. 旧索引：hash & 001111， 其实是保留 hash 的低四位，即保留低 n 位
2. 新索引：hash & 011111，其实是保留 hash 的低五位，即保留低 n+1 位

可以看出新索引和旧索引的差别取决于第 n+1 位（转换为十进制则为原 cap 大小）的值，如果该位为 1，则偏移，为 0 则为原索引，所以只需要计算该位便能确定是否需要偏移了，则也是为什么下文代码中采用 (e.hash & oldCap) == 0 的判断。

    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) {
            // 达到所能承载的最大值 2的30次方，直接返回，不再扩容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 2倍扩容，2倍阈值（仅当扩容后的容量小于最大值时）
            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;
                    // 数组元素为单个节点，则不改变hash值，直接插入新表
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 1. 数组元素为红黑树，涉及红黑树操作，后续补充
                    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;
                            }
                            //  原数组中的索引大小加原数组cap 时，构造链表
                            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;
    }

关于如何对红黑树进行迁移，则留在后续了。这里需要注意的是对于链表的迁移，划分了两种情况，定义了两个链表的头尾节点。因为针对不同的 hash 值，采用不同的迁移策略。

红黑树以及迭代器实现

红黑树和迭代器，我打算另起博文来写，这样会写的更透彻点。

推荐博文

---

手撕HashMap迭代器
手撕HashMap红黑树

我与风来

---

认认真真学习，做思想的产出者，而不是文字的搬运工
错误之处，还望指出