结合源码,初步分析了 HashMap 的结构和查询、新增、扩容操作

说到 HashMap,我们想到的就是映射和散列。映射,形象化地说又叫键值对,一个键对应一个值,这种特性使它的应用非常广泛;散列,我的理解就是利用哈希码提高查找的速度,一个好的哈希策略应该能够尽可能地避免冲突(碰撞),又能够节约存储空间。当碰撞发生时,要采取什么策略,也是一个难题。

HashMap 是 Java 应用中最常用的类型之一,属于不可不学的基础知识...So,打开源码,看看它牛逼在哪里。

本文将从相关数据结构和操作两个方面分析。

数据结构

在 JDK 1.7 中 HashMap 的组成是数组 + 链表,而 JDK 1.8 新增了红黑树结构,当链表的长度大于 8 时会转换为红黑树,以提升元素的操作性能。

图示:

java hashmap key存中文_链表

HashMap 用静态内部类 Node<K,V> 保存键值对,它包含四个字段:

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash; 
    final K key;
    V value;
    Node<K,V> next;

    // ...
}

注意区分:

  1. hash 字段是根据 key 计算得来的;
  2. Node 有自己的 hashCode 方法,返回Objects.hashCode(key) ^ Objects.hashCode(value);

在进一步学习之前,我们先整理一下 HashMap 中规定的几个重要常量:

  • 默认的初始化容量(DEFAULT_INITIAL_CAPACITY):16;
  • 最大容量(MAXIMUM_CAPACITY):1 << 30即 2^30;
  • 默认的负载因子(DEFAULT_LOAD_FACTOR):0.75;
  • 从链表变为红黑树的阈值(TREEIFY_THRESHOLD):8;
  • 从链表变为红黑树要求的最小容量(MIN_TREEIFY_CAPACITY):64;

这里有 3 个关键概念:容量、负载因子、树化(treeify)阈值。

1. 容量

容量指的是 HashMap 内部的Node<K,V>[]数组的大小,默认的初始化容量是 16,当空间不足时会自动扩容为原来的 2 倍,扩容后的大小始终是 2 的 n 次幂,并且要求 n <= 30。 可以在构造方法中指定初始化容量,记住必须是 2 的幂。

2. 装填因子

装填因子指明了什么时候对数组进行扩容,默认的装填因子是 0.75,也就意味着 Node 的数量超过容量的 75% 时就会进行扩容。“装填”一词,如果我们把每个数组元素看作一个桶(bucket),是不是就很形象?也可以在构造方法中自定义装填因子,不过一般不这么做,因为 0.75 被证明是一个合理的折中选择。

HashMap 有一个 int 类型的字段 threshold,它是扩容的临界值,初始化的计算公式是容量 * 装填因子,并且在每一次数组扩容后都会跟着扩大为原来的 2 倍。如果数组的容量已经达到最大值,threshold 取值为Integer.Max_VALUE。

3. 树化阈值

一个“桶”从链表转变为红黑树的阈值是 8。

源码注释:树节点的大小大约是普通节点的两倍,所以我们只在桶包含足够的节点时才使用树节点。当它们变得太小(由于删除或调整大小)时,就会被转换回普通的链表。在使用分布良好的哈希码时,很少需要使用树结构。

为什么是 8 呢?理想情况下,哈希码是随机出现的,选择装填因子为 0.75,则桶中节点的个数遵循泊松分布: $$P(x)=\frac{e{-1/2}·x{1/2}}{x!}$$ 节点个数和概率的对照表:

* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
* more: less than 1 in ten million

也就是说,在装填因子为 0.75,树化阈值为 8 的设计下,出现链表转红黑树的概率小于千万分之一。

链表转换成树还有一个最小容量限制,当容量小于 64 且某条链表长度大于 8 时,会进行扩容而不是 treeify。

操作

HashMap 有三个重要操作:

  • 查询
  • 新增
  • 扩容

下面我们来看看这些操作涉及到哪些逻辑。

1. 查询

首先看get方法的内部实现:

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
  1. 用hash方法对 key 生成散列值;
  2. 调用getNode方法找到 Node,返回 value。

hash策略如下:

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

当 key 是空值时,散列值是 0。不过后面的计算要怎么理解呢?举个栗子:

// 1) h:        11000110 11110010 00100110 11100011
// 2) h >>> 16: 00000000 00000000 11000110 11110010  // 逻辑右移
// 3) hash:     11000110 11110010 11100000 00010001

高 16 bit 不变,低 16 bit 与高 16 bit 进行了一次异或。

再看看索引的计算:

(n - 1) & hash // n为数组长度

用了与运算&而不是取余%,两者等价,但位运算效率更高。

假如长度是 16,则:

// 3) hash:  11000110 11110010 11100000 00010001
// 4) n - 1:                                1111
// 5) index:                                0001

索引为 1,hash 真正有效的只有低 4 bit。

源码注释:由于数组长度是 2 的幂,因此仅在较低位上变化的散列集总是会发生冲突。因此,我们应用了一个转换,将更高位的影响通过异或向下传播,在速度、效用和质量之间进行权衡。

下面的重点是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 &&
        // 根据hash计算索引
        (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)
                // 树结构则调用getTreeNode
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                // 先比较hash再调用equals
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

流程图:

java hashmap key存中文_java hashmap key存中文_02

思路总结:

  1. 根据 hash 计算 bucket 索引;
  2. bucket 里的第一个节点,直接命中;
  3. 如果有冲突,则通过key.equals(k)查找节点;
  4. 如果是树结构,O(logN);如果是链表,O(N)。

2. 新增

put方法的实现:

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

实际用的是putVal:

/**
 * @param hash key 的 hash
 * @param key 
 * @param value 
 * @param onlyIfAbsent 如果为 true,则不改变已经存在的 value
 * @param evict 如果为 true,表示 table 是创建状态
 * @return 旧的 value,如果没有则为 null
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 如果哈希表为空则调用resize
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 如果 bucket 为空,则根据索引直接创建节点
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 如果 bucket 不为空,开始查找
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 存在旧值
            e = p;
        // 如果是树结构,调用putTreeVal
        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) {
                    // 在链表尾插入,JDK 1.8 的优化部分
                    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) { // 存在键值对
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // size加1,如果超过threshold则扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

流程图:

java hashmap key存中文_链表_03

思路总结:

  1. 根据 hash 计算 bucket 索引;
  2. 如果 bucket 为空则直接创建;
  3. 如果碰撞了,对链表或树进行插入;
  4. 如果插入后链表过长,就转换成红黑树;
  5. 如果节点已经存在就替换旧值;
  6. 如果 size > threshold 就要扩容。

3. 扩容

扩容有两种情况:

  1. 初始化;
  2. 表大小扩为原来 2 倍。

如果哈希表(也就是内部数组)为空,则按照指定的初始容量创建一张表。否则每个元素要么保持相同的索引,要么偏移与旧表长度相同的距离。

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;
        }
        // 扩容为当前的 2 倍,但不能超过最大值
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    // 表不存在,初始化
    else if (oldThr > 0) // 初始化容量的值存放在字段 threshold 中
        newCap = oldThr;
    else { // threshold 等于 0 意味着使用默认的初始化容量
        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;
                // 如果 bucket 只有一个节点,则直接复制
                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 { // 链表,保持原有顺序
                    // JDK 1.8 扩容优化部分
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 遍历链表
                    do {
                        next = e.next;
                        // 索引不变(思考:为什么不是 e.hash & (newCap-1) == j ?)
                        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;
                        // 偏移长度是 oldCap
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }    
    return newTab;
}

判断是否保留原来的索引时,为什么用(e.hash & oldCap) == 0?

同一条链表中的节点 hash 值都是相同的,如果hash & (oldCap-1)等于hash & (newCap-1),意味着保留原来索引。不妨假设原先的数组长度是 32,扩容后的长度就是 64,讨论一下 hash 的两种情况:

1.假设 hash 为 150(0x1001 0110)

// hash               : 1001 0110
// hash & (0x011111)  : 0001 0110  有效位有 5 个
// hash & (0x111111)  : 0001 0110  有效位有 6 个
// 结论:保留原索引
// oldCap        : 0010 0000
// hash & oldCap : 0000 0000 == 0

2.假设 hash 为 182(0x1011 0110),改动了一个位

// hash               : 1011 0110
// hash & (0x011111)  : 0001 0110  有效位有 5 个
// hash & (0x111111)  : 0011 0110  有效位有 6 个
// 结论:索引需要偏移
// oldCap        : 0010 0000
// hash & oldCap : 0010 0000 != 0

也就是在“扩容 2 倍,始终是 2 的幂”的约束下,e.hash & oldCap的运算结果代表新增有效位是否为 1,如果是,就意味着hash & (oldCap-1)不等于hash & (newCap-1)。两个判断条件是等价的,设计者选择了效率更高的判断方式。

PS:最后,有一个问题,为什么 JDK 1.8 要特意改为链表尾正序插入?

原因是 JDK 1.7 中使用的首部倒序插入存在死循环问题,由于 HashMap 是线程不安全的,多个线程同时进行新增操作并触发扩容时,可能会使链表产生循环引用,这个问题的详细讨论可以参考:HashMap 在高并发下引起的死循环,杰哥长得帅,简书

END

参考:Java HashMap工作原理及实现,Yikun

如有错误,欢迎指正。