HashMap源码的简单分析

本文所有源码来自 JDK 1.8.0_181

HashMap简介

Map是Key-Value对映射的抽象接口，Map用于保存具有映射关系的数据。Map集合里有两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。key不允许重复，key和value之间存在单向一对一关系，通过key能找到相应的value。

HashMap是基于哈希表的Map接口的实现，以Key-Value的形式存在，即存储的对象是Entry(同时包含了Key和Value)。在HashMap中，根据hash算法来计算key-value的存储位置并进行快速存取。最多只允许一条Entry的键为Null，但允许多条Entry的值为Null。此外，HashMap是线程不安全的。

结构示意

当链表达到一定长度时会进行树化。

理想状态下哈希表的每个箱子中，元素的数量遵守泊松分布:

当负载因子为 0.75 时，上述公式中 λ 约等于 0.5，因此箱子中元素个数和概率的关系如下:

数量	概率
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

这就是为什么箱子中链表长度超过8以后要变成红黑树，因为在正常情况下出现这种现象的几率小到忽略不计。一旦出现，几乎可以认为是哈希函数设计有问题导致的。Java对哈希表的设计一定程度上避免了不恰当的哈希函数导致的性能问题，每一个箱子中的链表可以与红黑树切换。

最基本的存储单位

一个结点也就是一个键值对

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

        public final K getKey()        {
    return key; }
        public final V getValue()      {
    return value; }
        public final String toString() {
    return key + "=" + value; }

        public final int hashCode() {
   
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
   
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
   
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
   
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

一些关键的属性

    /* 默认初始化容量为16 */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

    /* 最大容量为2^30 */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /* 默认负载因子为0.75 */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /* 一个桶中结点的存储方式由链表转换成树的阈值。即当桶中结点的数量超过
     * TREEIFY_THRESHOLD时使用树来代替链表，默认值是8。 */
    static final int TREEIFY_THRESHOLD = 8;

    /* 当执行resize操作时，当桶中结点的数量少于UNTREEIFY_THRESHOLD时
     * 使用链表来代替树，默认值是6。 */
    static final int UNTREEIFY_THRESHOLD = 6;

    /* 当桶中的结点被树化时最小的hash表容量（如果hash表容量小于
     * MIN_TREEIFY_CAPACITY，当桶中bin的数量太多时会执行resize扩容操作），
     * 这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。 */
    static final int MIN_TREEIFY_CAPACITY = 64;

    /*哈希表，在第一次使用被初始化，必要时扩容，长度总为2的整数幂*/
    transient Node<K,V>[] table;

    /*键值对的集合*/
    transient Set<Map.Entry<K,V>> entrySet;
    
    /*这个map中的键值对的数量*/
    transient int size;

    /*HashMap修改的次数*/
    transient int modCount;
    
    /*当HashMap的size大于threshold时会执行resize操作。*/
    int threshold;

    /*负载因子*/
    final float loadFactor;

modCount的作用：HashMap是线程不安全的，在迭代时会将modCount赋值到迭代器的expectedModCount属性中，然后进行迭代，如果在迭代的过程中HashMap被其他线程修改了，modCount的数值就会发生变化,这个时候expectedModCount和ModCount不相等，会抛出ConcurrentModificationException()异常。

创建HashMap的方法

    // 指定初始容量和负载因子
    public HashMap(int initialCapacity, float loadFactor) {
   
        // 判断初始容量和负载因子是否合法
        if (initialCapacity < 0)