Java8 HashMap源码解读

注释解读

Map 接口的基于哈希表的实现。此实现提供所有可选的映射操作，并允许 null 值和 null 键。（HashMap 类与 Hashtable 大致等效，不同之处在于它不同步并允许为null。）类不能保证映射的顺序。特别是，它不能保证顺序会随着时间的推移保持恒定。
 
该实现为基本操作（get 和 put）提供了恒定时间的性能，假设哈希函数将元素正确地分散在存储桶中。集合视图上的迭代所需的时间与 HashMap 实例的“容量”（存储桶数）及其大小（键-值映射数）成正比。因此，如果迭代性能很重要，则不要将初始容量设置得过高（或负载因子过低），这一点非常重要。
 
HashMap 的实例具有两个影响其性能的参数：初始容量和负载系数。capacity 是哈希表中存储桶的数量，初始容量只是创建哈希表时的容量。负载因子是衡量哈希表在自动增加其容量之前的填充程度的度量。当哈希表中的条目数超过负载因子和当前容量的乘积时，哈希表将被 rehash（即，内部数据结构将被重建），此时哈希表将被扩容到大约桶数量的两倍。
 
通常，默认负载因子（0.75）在时间和空间成本之间提供了很好的折衷。较高的值会减少空间开销，但会增加查找成本（在 HashMap 类的大多数操作中都得到体现，包括 get 和 put）。设置其初始容量时，应考虑映射中的预期条目数及其负载因子，以最大程度地减少重新哈希操作的次数。如果初始容量大于最大条目数除以负载因子，则将不会进行任何哈希操作。
 
如果将许多映射存储在 HashMap 实例中，则创建具有足够大容量的映射将比让其根据需要自动执行重新哈希操作更有效。请注意，使用许多具有相同 hashCode 的键肯定会降低哈希表性能。为了改善影响，当键为 Comparable 时，此类可以使用键之间的比较顺序来帮助打破平局。
 
请注意，此实现未同步。如果多个线程同时访问一个哈希映射，并且至少有一个线程在结构上修改该映射，则它必须在外部进行同步。（结构修改是添加或删除一个或多个映射的任何操作；仅更改与实例已经包含的键相关联的值不是结构修改。）通常通过在自然封装了 map 的某个对象上进行同步来实现。
 
如果不存在这样的对象，则应使用 Collections.synchronizedMap 方法“包装” map。最好在创建时完成此操作，以防止意外地不同步访问 map
Map m = Collections.synchronizedMap(new HashMap())
 
此类的所有“集合视图方法”返回的迭代器都是 fail-fast ：如果在创建迭代器后的任何时间对结构进行了结构修改，除了通过迭代器自己的 remove 方法之外，迭代器将抛出 ConcurrentModificationException。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来不确定的时间冒任意不确定行为的风险。
 
注意，不能完全保证迭代器的快速失败行为，因为通常来说，在存在不同步的并发修改的情况下，不可能做出任何严格的保证。快速失败的迭代器会尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序以确保其正确性是错误的：迭代器的快速失败行为应仅用于检测错误。

关键常量

/**
 * 默认初始容量-必须为2的幂
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

/**
 * 在构造函数中未指定时使用的负载系数，默认为 0.75
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 使用树而不是链表的计数阈值。将元素添加到至少具有这么多节点的桶中时，桶会转换为树。该值必须大于2，并且至少应为8才能与树删除中的假设（即收缩时转换回普通桶）相吻合。
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 在 resize 期间用于取消树状化（拆分）的桶计数阈值。应小于TREEIFY_THRESHOLD，并且最多为6才能与树删除中的收缩检测相吻合。
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 可将桶变为树的哈希表的最小容量。（否则，如果桶中的节点过多，将会发生 resize 操作）应至少为4 * TREEIFY_THRESHOLD，以避免 resize 和树化阈值之间的冲突。
 */
static final int MIN_TREEIFY_CAPACITY = 64;

成员属性

/**
 * 哈希表，在首次使用时初始化，并根据需要调整大小。分配时，长度始终是2的幂。
 */
transient Node<K,V>[] table;

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

/**
 * 此映射中的键值对数量
 */
transient int size;

/**
 * 对该 HashMap 进行结构修改的次数，结构修改是指更改 HashMap 中的映射次数或以其他方式修改其内部结构（例如重新哈希）的修改。此字段用于使 HashMap 的集合视图上的迭代器快速失败。
 */
transient int modCount;

/**
 * 下一个需要进行 resize 操作的阈值，等于 capacity * loadFactor
 */
int threshold;

/**
 * 哈希表的负载因子。
 */
final float loadFactor;

核心方法

构造方法

以构造方法为入口进行分析：

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

整个构造方法逻辑很简单，重点看最后一行调用的tableSizeFor方法：

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

方法的注释阐明了这个方法的目的是将传入的容量大小转换为2的幂，为什么一定是要2的幂，后文进行分析，这里我们来分析下这个算法是怎么做到将传入的数字转换为2的幂。

2的幂有一个特点，就是高位为1，低位全部都是0，对于一个给定的数字，如果我们能把它不为1低位部分全部都补为1，然后再加1，这样进位后刚好就达到了2的幂的特点。

清楚了这个逻辑，我们再来看下这个方法中间做无符号右移的这几行代码，分析这个过程时可以完全忽略掉低位，只看为1的最高位。首先将 n 右移1位，再与原数字做按位或运算，运算后的结果可以保证原来为1的最高位和它的前一位都为1，因为原来为1的最高位右移后的结果保证了它的前1位是1，然后按位或操作后保证了这两位都是1。紧接着前面计算的结果又右移了两位，再进行按位或操作，这样保证了最终计算后的结果从最高位为的1的位开始，向前4位都是1，依次类推，int 型一共32位，整个中间这几行代码执行下来保证了这个 int 型的值从最高位为1的位开始向前的所有低位都为1，并在代码的最后一行为最后的计算结果加1转换成了2的幂。当然对于一个较小的数字，可能在前面一两次计算后，就已经达到了低位全部为1的状态，后面几次计算就没什么用了，但是不会影响结果。

我们用一个例子来解释一下这个逻辑，假如我们传入的容量是67，减1后的结果就是66，66的二进制表示为00000000 00000000 00000000 01000010，右移1位后为00000000 00000000 00000000 00100001，两者进行 | 运算的结果为：

  00000000 00000000 00000000 01000010
| 00000000 00000000 00000000 00100001
——————————————————————————————————————
  00000000 00000000 00000000 01100011

然后将结果00000000 00000000 00000000 01100011再右移两位结果为00000000 00000000 00000000 00011000，两者再进行 | 运算的结果为：

  00000000 00000000 00000000 01100011
| 00000000 00000000 00000000 00011000
——————————————————————————————————————
  00000000 00000000 00000000 01111011

然后将结果00000000 00000000 00000000 01111011再右移四位结果为00000000 00000000 00000000 00000111，两者再进行 | 运算的结果为：

  00000000 00000000 00000000 01111011
| 00000000 00000000 00000000 00000111
——————————————————————————————————————
  00000000 00000000 00000000 01111111

到这里66从最高位为1的位开始，向前的所有低位已经全部为1了，后面剩下的两次计算其实已经没用了，但是计算后的结果是不会变的，最后把00000000 00000000 00000000 01111111加1变成00000000 00000000 00000000 10000000也就是2的7次幂等于128，所以虽然我们传入的容量是67，但是最终经过计算后，本次创建的 HashMap 的初始容量实际上是128。

还有一个地方没有分析，tableSizeFor方法的第一行把传入的容量先减1然后在进行的下面的计算，为啥要减1呢？按照我们的分析，不减1应该也可以达到目的啊？没错，不减1也是能够将传入的容量转换为2的幂，但是如果我们传入的容量已经是2的幂，经过这个方法之后，容量会翻倍，这样就不太好了，违背了调用者的初衷，可能会造成资源浪费，所以在方法的第一行先把传入的容量减1，再进行下面的计算，这样即使传入的容量已经是2的幂，也可以保证经过计算后的容量是不会变的。

put

接下来分析 HashMap 几个核心的方法，首先来看 put 方法：

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

这里在进入putVal方法之前首先用 key 作为入参调用了一个hash方法：

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

我们知道，int 型是 32 位，这里首先将 key 的 hashcode 值右移16位再与原 hashcode 值进行异或运算，右移16位相当于把 hashcode 的低16位移除并把高16位移动到了低16位，然后再与原来的 hashcode 进行异或，这样操作下来的结果相当于高16位的没变，用高16位异或低16位的结果替换了原来的低16位进行混淆，这样做的目的是什么呢？

我们知道，HashMap 中维护了一个 table 数组，上面提到了 HashMap 默认初始容量为16，也就是数组的长度默认为16，而有符号的 int 型大概有40多亿个数字，但是数组没有这么大的下标，又不能直接初始化一个40多亿长度的数组，内存放不下，所以我们想到一个办法可以用 hashcode 与数组的长度进行取模运算来确定数组的下标，这看起来是个不错的方法，但也带来了新的问题，虽然 hashcode 值是很离散的，但是在与数组的长度进行取模运算时，高位几乎是没用的，只有低几位会在取模运算中起作用，比如我们向 HashMap 中 put hashcode 分别为100000163、200000163、300000163的三个键值对，这三个 hashcode 与16取模后的结果都是3，此时三个值都存在下标为3的数组空间中，这样 HashMap 直接退化成为链表了，这就很蛋疼了~ 所以这种方法会导致频繁的哈希碰撞，从而使 HashMap 的性能变低。

HashMap 采用上述的低位混淆操作后，在低位中增加了高位的特征，所以混淆后可以增大低位的随机性，从而降低发生哈希碰撞的概率，当然也仅仅是降低，没有办法完全避免哈希碰撞。上述例子中的三个 hashcode 经过 HashMap 的hash方法进行低位混淆后会变成100000854、200001864、300003906三个值，这三个值与16取模后的结果分别为6、8、2，这样三个键值对就分散在了数组的三个不同的下标中，从而避免了哈希碰撞。

我们继续来看 putVal 方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    // n 为数组的长度
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 当 table 为空时调用 resize 方法进行初始化，resize 方法稍后分析
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 判断 hash 值与数组长度取模后的下标中是否有节点，如果没有则新建节点并将当前的键值对存在这里
    // 为什么 (n - 1) & hash 这段代码相当于 hash 值与数组长度取模，后面会解释
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    	// 如果上面的 if 条件没有满足，后面要进行的操作分为两种，一种是存在相同的 key，则进行 value 的覆盖，第二种是发生了哈希冲突，要进行哈希冲突的处理
        Node<K,V> e; K k;
        // 判断如果下标中已有的节点的 hash 值与传入的 key 的 hash 值相等并且 equals 判断为 true，证明是相同的 key，则在后面进行 value 的覆盖
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
        	// 如果当前下标已存在的节点是树节点，则进行树节点的 put 处理，HashMap 树的操作我们会用单独文章来分析
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
        	// 到这里说明 table 当前下标对应的元素是一个链表，并且链表的头节点的 key 不是当前传入的 key，这时需要遍历链表来决定元素插入的位置
            for (int binCount = 0; ; ++binCount) {
            	// 如果下一个节点为 null，则创建新的节点将传入的元素存到下一个节点
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 判断当前链表的元素数量是否达到了应该树化的阈值，如果达到了，则尝试树化
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                    	// treeifyBin 方法稍后分析
                        treeifyBin(tab, hash);
                    break;
                }
                // 每次遍历用传入的元素与下一个节点进行 key 是否相等的判断，如果是相同的 key，同样在后面进行 value 的覆盖
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 这里的判断如果成立说明存在与传入的 key 相等的节点，需要进行 value 的覆盖
        if (e != null) {
            V oldValue = e.value;
            // onlyIfAbsent 用来判断如果 key 已经存在，是否要覆盖 value，默认的 put 方法传入的是 false，代表需要覆盖
            // HashMap 还有一个 putIfAbsent 方法，传入的是 true，代表如果 key 已经存在不要覆盖
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 发生 value 覆盖代表一次节点访问，afterNodeAccess 留给子类扩展做节点访问后的处理
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // 增加结构修改的次数，这个字段的作用上面介绍过
    ++modCount;
    // 如果新增节点后的节点数量大于当前需要扩容的阈值，则进行 resize
    if (++size > threshold)
        resize();
    // afterNodeInsertion 留给子类扩展做节点插入后的处理
    afterNodeInsertion(evict);
    return null;
}

方法逻辑简述：

1. 6-7行，在哈希表为空时初始化哈希表，HashMap 是在 put 操作时进行初始化动作，这种延迟初始化一定程度上可以节省内存资源，在真正用到时再做初始化。
2. 10-11行，本次 put 的 key 在哈希表中要放置的下标如果不存在节点，则创建一个新节点存放本次新增的键值对。
3. 12-52行，本次 put 的 key 在哈希表中要放置的下标已经存在节点（下面简称为已存在节点），则又分为以下几种情况：
   3.1 16-18行，本次传入的 key 与已存在节点的 key 相同，记录下已存在节点。
   3.2 19-20行，已存在节点如果为树节点，则进行树节点的 put 处理。
   3.3 22-40行，已存在节点为链表，并且链表的头节点的 key 不是当前传入的 key，这时需要遍历链表来决定元素插入的位置。同时需要考虑两个情况，一是在链表元素数量达到了应该树化的阈值时，进行树化；二是在遍历链表元素的过程中，发现了已存在节点的 key 与本次传入的 key 相等，同样需要记录下已存在节点。
   3.4 42-50行，如果上面3.1-3.3记录了已存在节点，则证明需要进行 value 覆盖的判断，如果方法传入的 onlyIfAbsent 不为 true 或者已存在节点的 value 为空，则进行覆盖，onlyIfAbsent 在调用 HashMap 的putIfAbsent时会传入 true，也就是如果 key 已存在，就不进行覆盖，普通的put方法是会进行覆盖的。
4. 53-60行，主要处理扩容情况，当节点数量大于要扩容的阈值时，进行扩容操作。

这里解释下为什么 (n - 1) & hash这段代码相当于 hash 值与数组长度取模，前面多次提到了 HashMap 的容量必须是2的幂，并且扩容也是双倍扩容，2的幂有一个特点，就是高位为1，低位全部都是0，以默认的容量16为例，16的二进制表示为00000000 00000000 00000000 00010000，对于任意一个整数，与16取模，如果这个数字小于16，取模后的结果就是这个数字本身，如果这个数字大于16，转换成二进制后，二进制大于等于5位的部分是可以忽略的，因为这些高位一定能够整除16，我们随便举个数字1234，1234转换成二进制是00000000 00000000 00000100 11010010，从第五位开始（包含第5位）往左的高位一定都是能够整除16的，而从第五位开始（不包含第5位）往右的低位加在一起是小于16的，取模的结果其实就是这些低位的和，直接保留就可以了。

经过上面的分析后再来看这段代码 (n - 1) & hash，16减1后的二进制为00000000 00000000 00000000 00001111，对于一个小于16的数字，与00000000 00000000 00000000 00001111进行按位与运算，结果实际上就等于这个数字本身，这个很好理解，对于任意一个大于16的数字，与00000000 00000000 00000000 00001111进行按位与运算，结果相当于这个数字从第五位开始（包含第5位）往左的高位都被忽略掉了，这些高位都是能够整除16的，所以忽略掉也是不会影响取模结果的，而从第五位开始（不包含第5位）往右的低位则是被完整的保留了下来，正好就相当于取模操作，HashMap 用了这种非常巧妙的方法完成了 hash 值的取模运算，而这种方式的执行效率比普通的 “%” 号取模运算可快多了，这也解释前面提到的为什么 HashMap 要求容量必须为2的幂。

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;
    }
    else if (oldThr > 0)
    	// 如果扩容阈值大于0，则将初始容量设置为阈值
        newCap = oldThr;
    else {
    	// 没有设置任何参数，则使用默认常量值进行初始化
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
    	// 计算新的 resize 阈值
        float ft = (float)newCap * loadFactor;
        // 如果超过最大容量，阈值置为 Integer.MAX_VALUE，不再扩容
        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) {
            	// 将旧表对应下标的位置置为 null
                oldTab[j] = null;
                if (e.next == null)
                	// 如果本次遍历的节点是单独的节点，也就是没有下一个节点，则直接用新表的容量进行取模计算，存储到新表的对应下标处
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                	// 树节点需要做树的拆分处理，HashMap 树的操作我们会用单独文章来分析
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else {
                	// 链表移动
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 判断节点在新旧表中的下标是否相同，为什么 (e.hash & oldCap) == 0 这断代码可以完成这个判断我们稍后会分析
                        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;
}

方法逻辑简介：

1. 6-31行：确定本次扩容的大小和阈值，分为以下几种情况：
   1.1 6-16行：如果当前哈希表的大小大于0，证明已经初始化过了，直接将容量大小和扩容阈值都改为原来的两倍。
   1.2 17-19行：构造 HashMap 时指定了初始容量大小，通过前文的构造方法分析我们看到，构造方法传入的 initialCapacity 经过运算后值赋值给了 threshold，这里将初始容量设置为threshold。
   1.3 20-24行：调用无参构造方法时，使用默认的初始容量和扩容阈值。
   1.4 25-31行：如果前面进入了1.2分支，这里需要使用新的容量大小计算新的扩容阈值。
2. 32-36行：构造新的哈希表，将扩容阈值和哈希表赋值为新的扩容阈值和哈希表。
3. 38-93行：在老哈希表（以下简称为旧表）不为空的情况下，需要遍历旧表将元素移动到新哈希表（以下简称为新表），移动过程分为以下几种情况：
   3.1 45-47行：当前元素是单独的节点，不为链表也不为树，则直接移动到新表。
   3.2 48-50行：当前元素是树节点，针对树节点需要做拆分处理。
   3.3 51-90行：当前元素为链表，链表中的所有节点在移动后不一定都会放在同一个下标内，所以这里分两种情况，一是节点在新旧表中的下标相同，二是节点在新旧表中的下标不同，这两种情况会分别构建一个新的链表存放到新表的两个下标内，为什么可以这样处理，请看下文的解释。

这里解释下 (e.hash & oldCap) == 0这段代码为什么可以用来判断节点在新旧表中的下标是否相同？我们先来回顾一下前文的取模算法 (n - 1) & hash，还是以默认的容量16为例，16的二进制为00000000 00000000 00000000 00010000，减1后的二进制为00000000 00000000 00000000 00001111，发生扩容后新的容量变为16 * 2 = 32，32的二进制为00000000 00000000 00000000 00100000，减1后的二进制为00000000 00000000 00000000 00011111。

任何整数在和00000000 00000000 00000000 00001111、00000000 00000000 00000000 00011111两者进行按位与操作时，只要保证第5位不为1，结果一定是一样的，而在这个例子中如果(e.hash & oldCap) == 0判断为 true，就相当于保证了第5位不为1，也就保证了无论使用新老容量的任意一个执行取模算法后的结果都是一样的，所以这段代码能够判断节点在新旧表中的下标是否相同。

方法的最后一行代码newTab[j + oldCap] = hiHead;，这里为什么节点在新旧表中的下标不同时可以直接用本次遍历的下标加上旧表的容量作为存储在新表的下标？还是以上面的例子为例，节点在新旧表中的下标不同说明(e.hash & oldCap) == 0判断为 false，按照上面的推论，可以证明 hash 值的二进制第5位为1，任何二进制第5位为1的 hash 值在和00000000 00000000 00000000 00001111、00000000 00000000 00000000 00011111两者进行按位与操作时，与后者按位与的结果刚好比与前者进行按位与的结果多了一个00000000 00000000 00000000 00010000，也就是多了一个旧表的容量16，所以节点在新旧表中的下标不同时可以直接用本次遍历的下标加上旧表的容量作为存储在新表的下标。HashMap 用这种非常巧妙的方法来完成链表节点的移动。

在前文分析put方法中，在当前链表的元素数量达到了应该树化的阈值时，会尝试树化：

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);
            // 如果尾节点为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)
        	// 树化处理，HashMap树的操作我们会用单独文章来分析
            hd.treeify(tab);
    }
}

get

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

这里的hash方法和下面的取模操作前文分析过。

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 根据 hash 值取模获取到哈希表对应下标的第一个节点元素
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 如果第一个节点的哈希值相等并且 key 是相同的 key，那第一个节点就是要寻找的节点，直接返回
        if (first.hash == hash &&
            ((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;
}

get方法的逻辑相对简单，根据当前传入的 key 计算对应的下标后，同样也是分当前下标节点即为要查找的节点、遍历树查找、遍历链表查找三种情况。

remove

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                          boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        // remove 方法前面这部分相当于执行了一遍 get 方法，先找到要移除的节点
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 找到了节点之后，根据传入的 matchValue 来判断是否要做 value 匹配，只有一个参数 key 的 remove 方法不做 value 匹配，包含两个参数 key value 的重载 remove 方法会做 value 匹配
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
            	// 如果节点为树节点，要做树节点移除的处理
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
            	// 如果根据 hash 值找到的节点即为待移除节点，直接将哈希表对应下标位置指向待移除节点的下一个节点即可，待移除节点没有了引用，就相当于被移除掉了
                tab[index] = node.next;
            else
            	// 如果根据 hash 值找到的节点不是待移除节点，则将待移除节点的上一个节点的下一个节点指向待移除节点的下一个节点，这样待移除节点没有了引用，就相当于被移除掉了
                p.next = node.next;
            // 增加结构修改的次数，这个字段的作用上面介绍过
            ++modCount;
            // 移除后递减哈希表中的元素数量
            --size;
            // afterNodeRemoval 方法留给子类做节点移除后的扩展
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

remove方法的逻辑也相对简单，7-25行相当于执行了一遍get方法，找到待移除的节点后，分几种情况处理：（1）如果待移除节点为树节点，要做树节点移除的处理；（2）如果待移除节点为头结点，则将哈希表对应下标的头结点置为头节点的下一个节点，待移除节点没有了引用，就相当于被移除掉了；（3）否则将待移除节点的上一个节点的下一个节点指向待移除节点的下一个节点，这样待移除节点没有了引用，就相当于被移除掉了。

到这里，HashMap 几个核心的方法就分析完了。