HashMap部分源码剖析

笔者所用JDK为 RedHat 的 OpenJDK-8u282-win64 版。

1. HashMap，存放键-值对（Key-Value）数据，可根据键生成的哈希值快速查找对应值，数组加链表实现（拉链法解决哈希冲突，此外，元素过多时单链表会转为红黑树，提高查询效率）。允许null作为Key或Value。所储存键值对数据无序（若要求有序可用TreeMap）。线程不安全（若要求线程安全可用ConcurrentHashMap），fail-fast（modCount成员保证）。

2. HashMap利用内置的哈希函数，用Key生成哈希码（将Key的hashCode的高16位与低16位进行异或，null的哈希码为0），通过哈希码对数组长度取模后得到的索引值访问元素。因此不同哈希码的元素可能会被映射到同一个索引值（即同一个桶内）。故当我们确定了元素所在的桶后，仍要同时利用哈希码和Key，在链表（或树）上遍历寻找对应元素。

   另：红黑树结构中，按照哈希码的大小确定元素具体位置，O(logN)。

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

3. capacity：数组的长度，默认值是16，最大可设置为 2^30，永为2的幂次。size：HashMap中存放的键值对数据总数（包括链表中的）。

4. loadFactor：负载因子，0到1之间的一个小数，描述数组存放数据的疏密程度，loadFactor默认值是0.75，过大会导致数据密，哈希冲突概率变大，链表变长，查找效率低下；过小会导致数据散，数组利用率不高。

5. threshold：扩容阈值。一般情况下，threshold = capacity * load factor，若 size > threshold，调用resize()方法对数组双倍扩容再散列。

   再散列会重新分布原HashMap的每个桶中的每个元素，跟据每元素对应高一位的哈希码情况，要么保持原位不动（高一位为0），要么在原索引值+oldCap的位置（高一位为1）。

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

6. 当某链表长度大于8时，若此时数组长度大于等于64，则将该链表转为红黑树（调用 treeifyBin() 方法），否则，双倍扩容再散列。当某红黑树的元素数小于6时，转回链表。

7. 由于哈希码为16位，而数组长度的取值范围是[1，2^30]，即最多可达30位。那么当数组长度是30位的时候，16位的哈希是无法做到全覆盖的。

   而此时，只会在低16位的数组增加元素，哈希冲突概率会不断增加，当触发阈值进行扩容时，由于数组长度已经是30位，故不会再进行扩容，只会将阈值设置为 Integer.MAX_VALUE。下一次，size又达到阈值，那么同样工作再做一次，但此时相当于啥都没干。由于HashMap有链表/红黑树解决哈希冲突，故即使数组长度不增加，仍可无限往里添加元素（除非内存限制），只是哈希冲突越来越严重，HashMap的性能下降。

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

8. HashMap的数组存放的链表结点 Node<K,V> 是单向链表，而树化后，扩展得到的 TreeNode<K,V>是单向链表+红黑树结构，即在转为红黑树结构的同时，保留了原有的链表结构。

   另：TreeNode继承自LinkedHashMap.Entry<K,V>，而LinkedHashMap继承了HashMap，Entry又继承自Node。Entry在Node的基础上增加了before，after成员变量，将其变为双向链表。TreeNode继承了Entry，增加了parent，left，right，prev，red变量，但在使用的时候，只用了单链表。

9. HashMap的构造函数只进行了参数的设定，并未实际分配数组空间。数组的分配是在第一次调用 put() 往里边存数据时进行的。此外，HashMap初始化时，若对capacity进行传参，则实际取到的capacity会是不小于参数的最小2幂次（最大2^30）。

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

10. HashMap的Key必须是不可变类或基本类型，即必须保证Key的hashCode的不变性。

    若要用自定义类作为Key，则必须重写equals和hashCode，保证相等对象hashCode一定相等，同时，保证其为不可变类：

    1. 类用final限定，使其不可被继承（避免子类继承父类后，破坏不可变性并冒充父类）；
    2. 所有成员变量必须私有（避免外部直接修改）；
    3. 所有成员变量加final，或者不提供改变成员变量的setter（避免间接修改）；
    4. 引用类型，构造器初始化时，传入深拷贝；
    5. 引用类型，getter方法返回深拷贝。

参考资料：

1. 看完还不懂HashMap算我输（附职场面试常见问题）。
2. 7000 字说清楚 HashMap，面试点都在里面了。
3. Java源码阅读之红黑树在HashMap中的应用 - JDK1.8。