HashMap（整理）

HashMap基于哈希表，底层结构由数组来实现，添加到集合中的元素以“key–value”形式保存到数组中，在数组中key–value被包装成一个实体来处理

由此首先介绍散列表

1、散列表

数组

数组是具有相同的数据类型且按一定次序排列的一组变量的集合体，数组在内存中的地址是连续的。

优点

• 随机访问性强（通过下标进行快速定位）
• 查找速度快

缺点

• 插入和删除效率低（插入和删除需要移动数据）
• 可能浪费内存（因为是连续的，所以每次申请数组之前必须规定数组的大小，如果大小不合理，则可能会浪费内存）
• 内存空间要求高，必须有足够的连续内存空间。
• 数组大小固定，不能动态拓展

链表

链表是一种数据结构，链表内存地址是散列、不连续的。

优点

• 插入删除速度快（因为有next指针指向其下一个节点，通过改变指针的指向可以方便的增加删除元素）
• 内存利用率高，不会浪费内存（可以使用内存中细小的不连续空间（大于node节点的大小），并且在需要空间的时候才创建空间）大小没有固定，拓展很灵活。

缺点

• 不能随机查找，必须从第一个开始遍历，查找效率低

散列表

综合数组能够快速查询跟链表方便增加删除的优势，引入了散列表。

散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。

散列函数定义： 每个关键字被映射到0到TableSize-1这个范围中的某个数，并且放到适当的单元中。

合理的散列函数应该满足一下两个特点：

• 关键字在单元间均匀分布
• 散列函数计算简单

由于单元数目有限，而关键字是用不完的。就会存在两个关键字映射到同一个值。这就是hash冲突。

为了解决哈希冲突，有常见的两种方法：

• 分离链接法
• 探测散列表

分离链接法

做法是将散列到同一个值的所有元素保留到一个链表中。

也就是说由数组跟链表实现。

查找

执行一次查找，首先通过使用hash函数，将对应的key关键字映射到数组的下标，也就是找到了对应的链表。接着遍历链表，通过对象的equals方法确定位置。

插入

• 首先查找，是否存在对应key，如果是，则覆盖。
• 如果是新元素，可以插入到对应链表的任意位置。一种较好的解决方案是插入到链表的前端。（新近插入的元素最有可能被再次访问）

删除

首先查找，然后在链表直接删除。

探测散列表

分离链接法存在一定的缺陷，使用了链表。由于给新单元分配地址需要时间，算法速度慢，其次还要实现链表这个结构。

另一种方法是不使用分离链接的散列表，它解决哈希冲突是尝试另外一些单元，直到找到空的单元为止。这种方法就是探测散列表。

由于hashmap底层就是采用的分离链接法的散列表，本博客不对这种方案做进一步讨论。

2、HashMap（JDK1.7及以前）

由于Hashmap实现Map接口，在具体介绍之前，我们先了解下Map接口本身，以便了解所有实现的共同点。

public interface Map<K,V> {

    //返回Map中的key--value的数目
    int size();

    //如果Map不包含任何key--value，则返回 true
    boolean isEmpty();

    //如果Map中包含指定key的映射，则返回true
    boolean containsKey(Object key);

    //如果此Map将一个或多个键映射到指定值，则返回 true
    boolean containsValue(Object value);

    //返回与指定键关联的值
    V get(Object key);

    //将指定值与指定键相关联
    V put(K key, V value);

    //从Map中删除键和关联的值
    V remove(Object key);

    //将指定Map中的所有映射复制到此map
    void putAll(java.util.Map<? extends K, ? extends V> m);

    //从Map中删除所有映射
    void clear();

    //返回Map中所包含键的Set集合
    Set<K> keySet();

    //返回 map 中所包含值的 Collection集合。
    Collection<V> values();

    //返回Map中所包含映射的Set视图。Set中的每个元素都是一个 Map.Entry 对象
    Set<java.util.Map.Entry<K, V>> entrySet();

    //比较指定对象与此 Map 的等价性
    boolean equals(Object o);

    //返回此 Map 的哈希码
    int hashCode();

    //Map集合中存储key--value的对象Entry，在Map集合内形成数组结构
    interface Entry<K,V> {

        V getValue();

        V setValue(V value);

        boolean equals(Object o);

        int hashCode();
    }
}

在HashMap中，Entry[]保存了集合中所有的键值对，当我们需要快速存储、获取、删除集合中的元素时，HashMap会根据hash算法来获得“键值对”在数组中存在的位置，以来实现对应的操作方法。

当出现哈希冲突时，在HashMap中，是通过链表的形式来解决的，在hash值重复的数组角标下，通过链表将新插入的元素依次排列，当然如果插入的key相同，那么我们会将新插入的value覆盖掉原有的value；

hashmap特点

• 允许存入null键，null值（null值只有一个，并存于数组第一个位置）
• 无序集合，而且顺序会随着元素的添加而随时改变（添加顺序，迭代顺序不一致）
• 随着元素的增加而动态扩容（与ArrayList原理一致）
• 不存在重复元素（得益于hashCode算法和equals方法）
• 线程不安全

HashMap源码讲解

存在以下疑问：

• HashMap底层数据结构如何？
• HashMap如何保存数据，增删改咋实现？
• HashMap如何扩容？
• 什么扩容的大小一定要是2的整数次幂，也就是2的N次方？
• hash函数如何实现？

成员变量

     
     //默认初始容量，容量必须为2的幂。
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
     //默认装载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
     //HashMap默认初始化的空数组
    static final Entry<?,?>[] EMPTY_TABLE = {};
     //HashMap中底层保存数据的数组：HashMap其实就是一个Entry数组
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
      //Hashmap中元素的个数：
    transient int size;
    //threshold：等于capacity * loadFactory，决定了HashMap能够放进去的数据量
    int threshold;
    //loadFactor：装载因子，默认值为0.75，它决定了bucket填充程度；
    final float loadFactor;
    //HashMap被操作的次数：
    transient int modCount;
    //映射容量的默认阈值
    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;

    /**

HashMap的最终实现

在HashMap中，基本存储单元是Entry,存储元素的是Entry[]数组，而其中的元素也就是Entry对象,，Entry是链表结构

static class Entry<K,V> implements Map.Entry<K,V> {
    //Entry属性-也就是HashMap的key
    final K key;

    //Entry属性-也就是HashMap的value
    V value;

    //指向下一个节点的引用：实现单向链表结构
    java.util.HashMap.Entry<K,V> next;

    //此Entry的hash值：也就是key的hash值
    int hash;

    // 构造函数：
    Entry(int h, K k, V v, java.util.HashMap.Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }
    public final K getKey() { return key;}
    public final V getValue() { return value; }
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    public final boolean equals(Object o) {

        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }
    public final int hashCode() {
        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }
    public final String toString() {
        return getKey() + "=" + getValue();
    }
    void recordAccess(java.util.HashMap<K,V> m) {
    }
    void recordRemoval(java.util.HashMap<K,V> m) {
    }
}

HashMap构造函数

最终都指定到了public HashMap(int initialCapacity, float loadFactor)方法中，对一些成员变量进行赋值。传入的初始容量，并没有改变Entry[]容量大小；

     //构造方法：初始化容量  指定装载因子
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
        //指定初始化容量大于 HashMap规定最大容量的话，就将其设置为最大容量；
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //不能小于0，判断参数float的值是否是数字
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
        //装载因子赋值：
        this.loadFactor = loadFactor;
        //初始容量赋值给 临界值属性
        threshold = initialCapacity;
        //空方法：没有任何实现
        init();
    }

    //构造方法：初始化容量
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    //无参构造：默认初始化容量16、默认装载因子0.75
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }

哈希函数

根据元素特征计算元素数组下标的方法就是哈希算法.

• hash ：该方法主要是将Object转换成一个整型。也就是对应key的特征值。

• indexFor ：该方法主要是将hash生成的整型转换成链表数组中的下标。

hash方法这段代码是为了对key的hashCode进行扰动计算，防止不同hashCode的高位不同但低位相同导致的hash冲突。简单点说，就是为了把高位的特征和低位的特征组合起来，降低哈希冲突的概率，也就是说，尽量做到任何一位的变化都能对最终得到的结果产生影响。

 final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();
        
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

indexFor相当于取模运算，将对应的hash值映射到数组空间。

Java之所有使用位运算(&)来代替取模运算(%)：

• 最主要的考虑就是效率。位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。

• 除了性能之外，还有一个好处就是可以很好的解决负数的问题。因为对负数取模比较复杂。使用二进制与操作就可以避免了。

static int indexFor(int h, int length) {
     
        return h & (length-1);
    }

实现原理：X % 2^n = X & (2^n – 1)

可以得出h%length相当于h & (length-1)

属性hashSeed说明

如果hashSeed进行了初始化，那么添加到HashMap中的字符串将会调用sun.misc.Hashing.stringHash32()方法来计算hash值。

HashMap重要方法

添加K-V：put()方法

  public V put(K key, V value) {
    //如果调用put方法时(第一次调用put方法)，还是空数组，则进行初始化操作
    if (table == EMPTY_TABLE) {
        //进行初始化HashMap的table属性，进行容量大小设置
        inflateTable(threshold);
    }
    //如果新增的key为null:
    if (key == null)
        //调用key为null的新增方法：
        return putForNullKey(value);

    //计算新增元素的hash值：
    int hash = hash(key);

    //根据hash值和数组长度，计算出新增的元素应该位于数组的哪个角标下：
    int i = indexFor(hash, table.length);

    //判断计算出的角标下，是否有相同的key，可以理解遍历该角标下的链表
    for (java.util.HashMap.Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        //根据计算出的hash值，以及 equals方法 / == 来判断key是否相同：
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            //key相同，则替换原有key下的value：
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            //返回被替换的值：
            return oldValue;
        }
    }
    modCount++;
    //向HashMap中增加元素：
    addEntry(hash, key, value, i);
    return null;
    }

在进行key一致性判断:首先通过hash值判断，再通过equals()或者==进行判断

因为每一个对象的hashCode()可以进行重写，既然可以重写，那么就可能会出现相同的hash值。退一步说，哪怕使用JDK默认的计算方式，也会出现重复的可能。所以在进行完hash值比较后，还进行了equals()或者==的判断

既然使用了equals()方法，为什么还要进行==判断呢？

主要是为了解决字符串的原因，

• 对于字符串来说，“==”比较两个变量本身的值，即两个对象在内存中的首地址。而“equals()”比较字符串中所包含的内容是否相同。

• 但是对于非字符串的对象来说，"=="和"equals"都是用来比较对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。

table初始化

调用hashMap的构造方法，table（Entry[]数组）还没有进行初始化。

每次调用put方法，如table还是一个空数组的时候，对数组进行初始化。

//初始化Entry数组，默认16个大小：
private void inflateTable(int toSize) {
    //获取要创建的数组容量大小：计算大于等于toSize的2的次幂（2的几次方）
    int capacity = roundUpToPowerOf2(toSize);
    //计算HashMap的阀值：
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    //创建Entry数组对象，重新对table赋值：
    table = new java.util.HashMap.Entry[capacity];
    //判断是否需要初始化hashSeed属性：
    initHashSeedAsNeeded(capacity);
}

//计算大于等于number的2的幂数（2的几次方）
private static int roundUpToPowerOf2(int number) {
    //在number不大于MAXIMUM_CAPACITY的情况下：
    return number >= MAXIMUM_CAPACITY ? 
        MAXIMUM_CAPACITY : 
            //再次进行三目运算：核心方法Integer.highestOneBit()
            (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}

补充：Integer.highestOneBit(num)只保留二进制的最高位的1，其余全为0；

问题：为什么table（Entry[]数组）的数组容量大小一定为大于设定值的2的次幂

• 方便Java使用位运算(&)来代替取模运算(%)；

  • 最主要的考虑就是效率。位运算(&)效率要比代替取模运算(%)高很多，主要原因是位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。

  • 除了性能之外，还有一个好处就是可以很好的解决负数的问题。因为对负数取模比较复杂。使用二进制与操作就可以避免了。

• (length- 1) 与 hash 值做与操作，当llength为2的n次幂，length-1就是最高位为0，其他位全是1 的数。key的hash值不会受到与运算对数据的变化影响。这样使得Hash值在table数组上散列均匀分布。

Hashmap的扩容机制

扩容触发的条件：

• 存放新值的时候当前已有元素的个数必须大于等于阈值（threshold：等于capacity * loadFactory，决定了HashMap能够放进去的数据量）

• 存放新值的时候当前存放数据发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值）

如果需要扩容，调用扩容的方法resize(),新数组的长度为原来数组长度的两倍，在实际扩容时候把原来数组中的元素放入新的数组中。

void resize(int newCapacity) {
　　　　Entry[] oldTable = table;
　　　　int oldCapacity = oldTable.length;
　　　　//判断是否有超出扩容的最大值，如果达到最大值则不进行扩容操作
　　　　if (oldCapacity == MAXIMUM_CAPACITY) {
　　　　　　threshold = Integer.MAX_VALUE;
　　　　　　return;
　　　　}
 
　　　　Entry[] newTable = new Entry[newCapacity];
　　　　// transfer()方法把原数组中的值放到新数组中
　　　　transfer(newTable, initHashSeedAsNeeded(newCapacity));
　　　　//设置hashmap扩容后为新的数组引用
　　　　table = newTable;
　　　　//设置hashmap扩容新的阈值
　　　　threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
　　}
 

transfer()在实际扩容时候把原来数组中的元素放入新的数组中

void transfer(Entry[] newTable, boolean rehash) {
　　　　int newCapacity = newTable.length;
　　　　for (Entry<K,V> e : table) {
　　　　　　while(null != e) {
　　　　　　　　Entry<K,V> next = e.next;
　　　　　　　　if (rehash) {
　　　　　　　　　　e.hash = null == e.key ? 0 : hash(e.key);
　　　　　　　　}
　　　　　　　　//通过key值的hash值和新数组的大小算出在当前数组中的存放位置
　　　　　　　　int i = indexFor(e.hash, newCapacity);
　　　　　　　　e.next = newTable[i];
　　　　　　　　newTable[i] = e;
　　　　　　　　e = next;
　　　　　　}
　　　　}
　　}

HashMap多线程操作导致死循环问题

在多线程下，进行 put 操作会导致 HashMap 死循环，原因在于HashMap 的扩容 resize()方法。由于扩容是新建一个数组，复制原数据到数组。由于数组下标挂有链表，所以需要复制链表，但是多线程操作有可能导致环形链表。

HashMap默认加载因子为什么选择0.75

HashMap有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动扩容之前可以达到多满的一种度量。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行扩容、rehash操作（即重建内部数据结构），扩容后的哈希表将具有两倍的原容量。

加载因子需要在时间和空间成本上寻求一种折衷。加载因子过高，例如为1，虽然减少了空间开销，提高了空间利用率，但同时也增加了查询时间成本；加载因子过低，例如0.5，虽然可以减少查询时间成本，但是空间利用率很低，同时提高了rehash操作的次数。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少rehash操作次数，所以，一般在使用HashMap时建议根据预估值设置初始容量，减少扩容操作。

选择0.75作为默认的加载因子，完全是时间和空间成本上寻求的一种折衷选择

HashMap实现多线程

• Hashtable替换HashMap
• Collections.synchronizedMap将HashMap包装起来
• ConcurrentHashMap替换HashMap

3、HashMap（JDK1.8）

数据结构：引入了 红黑树

关于 红黑树 的简介:

成员变量

 /** 
   * 主要参数 同  JDK 1.7 
   * 即：容量、加载因子、扩容阈值（要求、范围均相同）
   */

  // 1. 容量（capacity）： 必须是2的幂 & <最大容量（2的30次方）
  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认容量 = 16 = 1<<4 = 00001中的1向左移4位 = 10000 = 十进制的2^4=16
  static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量 =  2的30次方（若传入的容量过大，将被最大值替换）

  // 2. 加载因子(Load factor)：HashMap在其容量自动增加前可达到多满的一种尺度 
  final float loadFactor; // 实际加载因子
  static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认加载因子 = 0.75

  // 3. 扩容阈值（threshold）：当哈希表的大小 ≥ 扩容阈值时，就会扩容哈希表（即扩充HashMap的容量） 
  // a. 扩容 = 对哈希表进行resize操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数
  // b. 扩容阈值 = 容量 x 加载因子
  int threshold;

  // 4. 其他
  transient Node<K,V>[] table;  // 存储数据的Node类型 数组，长度 = 2的幂；数组的每个元素 = 1个单链表
  transient int size;// HashMap的大小，即 HashMap中存储的键值对的数量
 

  /** 
   * 与红黑树相关的参数
   */
   // 1. 桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树
   static final int TREEIFY_THRESHOLD = 8; 
   // 2. 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（此时HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 < 6时，则将 红黑树转换成链表
   static final int UNTREEIFY_THRESHOLD = 6;
   // 3. 最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树）
   // 否则，若桶内元素太多时，则直接扩容，而不是树形化
   // 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
   static final int MIN_TREEIFY_CAPACITY = 64;
  

数据结构 & 参数方面与 JDK 1.7的区别

数组元素 & 链表节点的 实现类

HashMap中的数组元素 & 链表节点 采用 Node类 实现

• 与 JDK 1.7 的对比（Entry类），仅仅只是换了名字

/** 
  * Node  = HashMap的内部类，实现了Map.Entry接口，本质是 = 一个映射(键值对)
  * 实现了getKey()、getValue()、equals(Object o)和hashCode()等方法
  **/  

  static class Node<K,V> implements Map.Entry<K,V> {

        final int hash; // 哈希值，HashMap根据该值确定记录的位置
        final K key; // key
        V value; // 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 V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

      /** 
        * hashCode（） 
        */
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

      /** 
        * equals（）
        * 作用：判断2个Entry是否相等，必须key和value都相等，才返回true  
        */
        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;
        }
    }

红黑树节点 实现类

HashMap中的红黑树节点 采用 TreeNode 类 实现

 /**
  * 红黑树节点 实现类：继承自LinkedHashMap.Entry<K,V>类
  */
  static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {  

    // 属性 = 父节点、左子树、右子树、删除辅助节点 + 颜色
    TreeNode<K,V> parent;  
    TreeNode<K,V> left;   
    TreeNode<K,V> right;
    TreeNode<K,V> prev;   
    boolean red;   

    // 构造函数
    TreeNode(int hash, K key, V val, Node<K,V> next) {  
        super(hash, key, val, next);  
    }  
  
    // 返回当前节点的根节点  
    final TreeNode<K,V> root() {  
        for (TreeNode<K,V> r = this, p;;) {  
            if ((p = r.parent) == null)  
                return r;  
            r = p;  
        }  
    } 

加载因子

添加数据put

在该步骤中，与JDK 1.7的差别较大：

添加流程如下

源码如下：

 /**
     * 源码分析：主要分析HashMap的put函数
     */
    public V put(K key, V value) {
        // 1. 对传入数组的键Key计算Hash值 ->>分析1
        // 2. 再调用putVal（）添加数据进去 ->>分析2
        return putVal(hash(key), key, value, false, true);

先说一下hash函数。

分析一：hash（key）

   /**
     * 分析1：hash(key)
     * 作用：计算传入数据的哈希码（哈希值、Hash值）
     * 该函数在JDK 1.7 和 1.8 中的实现不同，但原理一样 = 扰动函数 = 使得根据key生成的哈希码（hash值）分布更加均匀、更具备随机性，避免出现hash值冲突（即指不同key但生成同1个hash值）
     * JDK 1.7 做了9次扰动处理 = 4次位运算 + 5次异或运算
     * JDK 1.8 简化了扰动函数 = 只做了2次扰动 = 1次位运算 + 1次异或运算
     */

      // JDK 1.7实现：将 键key 转换成 哈希码（hash值）操作  = 使用hashCode() + 4次位运算 + 5次异或运算（9次扰动）
      static final int hash(int h) {
        h ^= k.hashCode(); 
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
     }

      // JDK 1.8实现：将 键key 转换成 哈希码（hash值）操作 = 使用hashCode() + 1次位运算 + 1次异或运算（2次扰动）
      // 1. 取hashCode值： h = key.hashCode() 
      // 2. 高位参与低位的运算：h ^ (h >>> 16)  
      static final int hash(Object key) {
           int h;
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
            // a. 当key = null时，hash值 = 0，所以HashMap的key 可为null      
            // 注：对比HashTable，HashTable对key直接hashCode（），若key为null时，会抛出异常，所以HashTable的key不可为null
            // b. 当key ≠ null时，则通过先计算出 key的 hashCode()（记为h），然后 对哈希码进行 扰动处理： 按位 异或（^） 哈希码自身右移16位后的二进制
     }

   /**
     * 计算存储位置的函数分析：indexFor(hash, table.length)
     * 注：该函数仅存在于JDK 1.7 ，JDK 1.8中实际上无该函数（直接用1条语句判断写出），但原理相同
     * 为了方便讲解，故提前到此讲解
     */
     static int indexFor(int h, int length) {  
          return h & (length-1); 
          // 将对哈希码扰动处理后的结果 与运算(&) （数组长度-1），最终得到存储在数组table的位置（即数组下标、索引）
          }

总结 ：计算存放在数组 table 中的位置（即数组下标、索引）的过程

• 此处与 JDK 1.7的区别在于：hash值的求解过程中 哈希码的二次处理方式（扰动处理）

• 步骤1、2 = hash值的求解过程
  

分析二：putVal(hash(key), key, value, false, true)

此处有2个主要讲解点：

• 计算完存储位置后，具体该如何 存放数据 到哈希表中
• 具体如何扩容，即 扩容机制

计算完存储位置后，具体该如何存放数据到哈希表中

由于数据结构中加入了红黑树，所以在存放数据到哈希表中时，需进行多次数据结构的判断：数组、红黑树、链表

• 与 JDK 1.7的区别： JDK 1.7只需判断 数组 & 链表

源码如下：

   /**
     * 分析2：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;

        // 1. 若哈希表的数组tab为空，则 通过resize() 创建
        // 所以，初始化哈希表的时机 = 第1次调用put函数时，即调用resize() 初始化创建
        // 关于resize（）的源码分析将在下面讲解扩容时详细分析，此处先跳过
        if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;

        // 2. 计算插入存储的数组索引i：根据键值key计算的hash值 得到
        // 此处的数组下标计算方式 = i = (n - 1) & hash，同JDK 1.7中的indexFor（），上面已详细描述

        // 3. 插入时，需判断是否存在Hash冲突：
        // 若不存在（即当前table[i] == null），则直接在该数组位置新建节点，插入完毕
        // 否则，代表存在Hash冲突，即当前存储位置已存在节点，则依次往下判断：a. 当前位置的key是否与需插入的key相同、b. 判断需插入的数据结构是否为红黑树 or 链表
        if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);  // newNode(hash, key, value, null)的源码 = new Node<>(hash, key, value, next)

    else {
        Node<K,V> e; K k;

        // a. 判断 table[i]的元素的key是否与 需插入的key一样，若相同则 直接用新value 覆盖 旧value
        // 判断原则：equals（）
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;

        // b. 继续判断：需插入的数据结构是否为红黑树 or 链表
        // 若是红黑树，则直接在树中插入 or 更新键值对
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); ->>分析3

        // 若是链表,则在链表中插入 or 更新键值对
        // i.  遍历table[i]，判断Key是否已存在：采用equals（） 对比当前遍历节点的key 与 需插入数据的key：若已存在，则直接用新value 覆盖 旧value
        // ii. 遍历完毕后仍无发现上述情况，则直接在链表尾部插入数据
        // 注：新增节点后，需判断链表长度是否>8（8 = 桶的树化阈值）：若是，则把链表转换为红黑树
        
        else {
            for (int binCount = 0; ; ++binCount) {
                // 对于ii：若数组的下1个位置，表示已到表尾也没有找到key值相同节点，则新建节点 = 插入节点
                // 注：此处是从链表尾插入，与JDK 1.7不同（从链表头插入，即永远都是添加到数组的位置，原来数组位置的数据则往后移）
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);

                    // 插入节点后，若链表节点>数阈值，则将链表转换为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        treeifyBin(tab, hash); // 树化操作
                    break;
                }

                // 对于i
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;

                // 更新p指向下一个节点，继续遍历
                p = e;
            }
        }

        // 对i情况的后续操作：发现key已存在，直接用新value 覆盖 旧value & 返回旧value
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e); // 替换旧值时会调用的方法（默认实现为空）
            return oldValue;
        }
    }

    ++modCount;

    // 插入成功后，判断实际存在的键值对数量size > 最大容量threshold
    // 若 > ，则进行扩容 ->>分析4（但单独讲解，请直接跳出该代码块）
    if (++size > threshold)
        resize();

    afterNodeInsertion(evict);// 插入成功时会调用的方法（默认实现为空）
    return null;

}

    /**
     * 分析3：putTreeVal(this, tab, hash, key, value)
     * 作用：向红黑树插入 or 更新数据（键值对）
     * 过程：遍历红黑树判断该节点的key是否与需插入的key 相同：
     *      a. 若相同，则新value覆盖旧value
     *      b. 若不相同，则插入
     */

     final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       int h, K k, V v) {
            Class<?> kc = null;
            boolean searched = false;
            TreeNode<K,V> root = (parent != null) ? root() : this;
            for (TreeNode<K,V> p = root;;) {
                int dir, ph; K pk;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0) {
                    if (!searched) {
                        TreeNode<K,V> q, ch;
                        searched = true;
                        if (((ch = p.left) != null &&
                             (q = ch.find(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.find(h, k, kc)) != null))
                            return q;
                    }
                    dir = tieBreakOrder(k, pk);
                }

                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    Node<K,V> xpn = xp.next;
                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    xp.next = x;
                    x.parent = x.prev = xp;
                    if (xpn != null)
                        ((TreeNode<K,V>)xpn).prev = x;
                    moveRootToFront(tab, balanceInsertion(root, x));
                    return null;
                }
            }
        }

扩容机制（即 resize（）函数方法）

扩容流程如下

源码分析

   /**
     * 分析4：resize（）
     * 该函数有2种使用情况：1.初始化哈希表 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;

    // 针对情况2：若扩容前的数组容量超过最大值，则不再扩充
    if (oldCap > 0) {
        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; // 通过右移扩充2倍
    }

    // 针对情况1：初始化哈希表（采用指定 or 默认值）
    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);
    }

    // 计算新的resize上限
    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) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;

                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 { // 链表优化重hash的代码块
                    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;
                        }
                        // 原索引 + oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

扩容流程（含 与 JDK 1.7 的对比）

哈希表如何解决Hash冲突

为什么HashMap具备下述特点：键-值（key-value）都允许为空、线程不安全、不保证有序、存储位置随时间变化

为什么 HashMap 中 String、Integer 这样的包装类适合作为 key 键