HashMap源码解读—Java8版本

---

推荐阅读：Java小白进阶架构师学习路线

---

---

---

相关阅读

• 【手撕源码系列】ArrayList源码解读—Java8版本
• 【手撕源码系列】LinkedList源码解读—Java8版本
• 深入浅出fail-fast机制
• ArrayList与迭代器模式

---

---

一、HashMap简介

HashMap顶部有一段很长的注释，大概的介绍了HashMap。

1.1 原文

/**
 * Hash table based implementation of the Map interface.  This
 * implementation provides all of the optional map operations, and permits
 * null values and the null key.  (The HashMap
 * class is roughly equivalent to Hashtable, except that it is
 * unsynchronized and permits nulls.)  This class makes no guarantees as to
 * the order of the map; in particular, it does not guarantee that the order
 * will remain constant over time.
 *
 * 
This implementation provides constant-time performance for the basic
 * operations (get and put), assuming the hash function
 * disperses the elements properly among the buckets.  Iteration over
 * collection views requires time proportional to the "capacity" of the
 * HashMap instance (the number of buckets) plus its size (the number
 * of key-value mappings).  Thus, it's very important not to set the initial
 * capacity too high (or the load factor too low) if iteration performance is
 * important.
 *
 * 
An instance of HashMap has two parameters that affect its
 * performance: initial capacity and load factor.  The
 * capacity is the number of buckets in the hash table, and the initial
 * capacity is simply the capacity at the time the hash table is created.  The
 * load factor is a measure of how full the hash table is allowed to
 * get before its capacity is automatically increased.  When the number of
 * entries in the hash table exceeds the product of the load factor and the
 * current capacity, the hash table is rehashed (that is, internal data
 * structures are rebuilt) so that the hash table has approximately twice the
 * number of buckets.
 *
 * 
As a general rule, the default load factor (.75) offers a good
 * tradeoff between time and space costs.  Higher values decrease the
 * space overhead but increase the lookup cost (reflected in most of
 * the operations of the HashMap class, including
 * get and put).  The expected number of entries in
 * the map and its load factor should be taken into account when
 * setting its initial capacity, so as to minimize the number of
 * rehash operations.  If the initial capacity is greater than the
 * maximum number of entries divided by the load factor, no rehash
 * operations will ever occur.
 *
 * 
If many mappings are to be stored in a HashMap
 * instance, creating it with a sufficiently large capacity will allow
 * the mappings to be stored more efficiently than letting it perform
 * automatic rehashing as needed to grow the table.  Note that using
 * many keys with the same {@code hashCode()} is a sure way to slow
 * down performance of any hash table. To ameliorate impact, when keys
 * are {@link Comparable}, this class may use comparison order among
 * keys to help break ties.
 *
 * 
Note that this implementation is not synchronized.
 * If multiple threads access a hash map concurrently, and at least one of
 * the threads modifies the map structurally, it must be
 * synchronized externally.  (A structural modification is any operation
 * that adds or deletes one or more mappings; merely changing the value
 * associated with a key that an instance already contains is not a
 * structural modification.)  This is typically accomplished by
 * synchronizing on some object that naturally encapsulates the map.
 *
 * If no such object exists, the map should be "wrapped" using the
 * {@link Collections#synchronizedMap Collections.synchronizedMap}
 * method.  This is best done at creation time, to prevent accidental
 * unsynchronized access to the map:
 *   Map m = Collections.synchronizedMap(new HashMap(...));
 *
 * 
The iterators returned by all of this class's "collection view methods"
 * are fail-fast: if the map is structurally modified at any time after
 * the iterator is created, in any way except through the iterator's own
 * remove method, the iterator will throw a
 * {@link ConcurrentModificationException}.  Thus, in the face of concurrent
 * modification, the iterator fails quickly and cleanly, rather than risking
 * arbitrary, non-deterministic behavior at an undetermined time in the
 * future.
 *
 * 
Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.  Fail-fast iterators
 * throw ConcurrentModificationException on a best-effort basis.
 * Therefore, it would be wrong to write a program that depended on this
 * exception for its correctness: the fail-fast behavior of iterators
 * should be used only to detect bugs.
 *
 * 
This class is a member of the
 * 
 * Java Collections Framework.
 *
 * @param  the type of keys maintained by this map
 * @param  the type of mapped values
 *
 * @author  Doug Lea
 * @author  Josh Bloch
 * @author  Arthur van Hoff
 * @author  Neal Gafter
 * @see     Object#hashCode()
 * @see     Collection
 * @see     Map
 * @see     TreeMap
 * @see     Hashtable
 * @since   1.2
 */
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
...
}

1.2 翻译

Map接口是基于哈希表实现的，这个实现为map提供了许多操作方法，允许key是null，或者values是null。HashMap大致和Hashtable一样，不同之处在于HashMap线程不同步，同时允许有null值。这个类不保证map的顺序，特别是它不能保证每次都顺序不变。

HashMap的实现为基础操作get和put方法提供了不变的性能表现，假设哈希函数在buckets中按比例分散元素，迭代器需要时间比例对hashmap实例（buckets的数量）的容量进行扩容（key-value映射的数量）。因此，如果迭代器性能很重要时，就不要给它的初始容量设置太高（或者加载因子太低）

一个Hashmap的实例会有两个参数影响它的性能表现：initial capacity初始值和load factor加载因子，capacity是哈希表中buckets的数量，初始值就是哈希表在被创建时的容量。加载因子是用来判断当哈希表到多满时才被允许自动扩容。当哈希表中的键值对超过了负载因子的乘积和当前的容量时，哈希表会通过rehashed的方法重新计算，（重建内部数据结构）这样一来哈希表大致会变成原有buckets的数量的两倍。

作为一条普遍的规则，默认的加载因子是0.75，它提供了很好的性能表现在时间和空间成本上。比0.75高就会降低整体空间，但是增加了查找的成本（这反应在绝大多数的HashMap操作，包括get和put方法）。当设置init capacity初始化值时，键值对的数量和它的负载因子应该被考虑进去，这样才能最小程度的降低重新计算哈希值的操作。如果初始化值比在被负载因子分发后的最大键值对数还要大时，重新计算哈希值的操作就会发生。

如果许多映射关系被存到一个hashMap实例中，创建足够大的容量让键值对被存储,会比让他们自动计算哈希值去扩容更高效。要注意的是，拥有同样哈希值的keys会降低所有哈希表的性能。为了改进这个影响，当keys在调用Comparable接口时，这个类利用比较顺序来帮助keys打破僵局。

需要注意的是这个方法不是同步的。如果多线程同时进入一个哈希映射时，并且至少有一个线程改变了map的结构时，它必须要在外面被同步。（结构性的修改可以时任何添加，删除更多键值对的操作，几乎不改变一个键的值，就说明这不是一个结构性的改变）。这些通常发生在当一些对象要被同步放进map时。

如果没有这样的对象存在，map必须要使用Collections.synchronizedMap方法包围，这是在创建时最好的做法，阻止意外的不同步map操作。
Map m = Collections.synchronizedMap(new HashMap(…));

迭代器返回了几乎所有集合都有的fail-fast的方法：如果map在迭代器被创建后的任何时间被结构性的改变，那么除了迭代器使用自己的remove方法，其他情况下迭代器都被抛出一个一场ConcurrentModificationException。因此，在同时被改变的时候，迭代器会比随时可能发生的风险，或者在不确定的时间下发生的不确定行为，失败的更快更利落。

需要注意的是，一个迭代器的快速失败行为不能被保证，一般来说，不可能完全保证不同步情况下的的同时修改结构的事情发生。快速失败迭代器会在一个最好的基础上抛出ConcurrentModificationException异常。因此，如果一个程序通过这个异常来判断它对错的行为是错误的，迭代器的快速失败行为只能用于检测bugs

1.3 一语中的

HashMap 是一个关联数组、哈希表，它是线程不安全的，允许key为null,value为null。遍历时无序。

其底层数据结构是数组称之为哈希桶，每个桶里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。

在JDK8中，当链表长度达到8，会转化成红黑树，此过程称为树化，以提升它的查询、插入效率，它实现了Map, Cloneable, Serializable接口。当链表长度小于6，会从红黑树转化为链表。

因其底层哈希桶的数据结构是数组，所以也会涉及到扩容的问题。
当HashMap的容量达到threshold域值时，就会触发扩容。扩容前后，哈希桶的长度一定会是2的次方。
这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。

而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。

因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。

但就算原本的hashCode()取得很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。 即，碰撞率会增大。

扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）

扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。

扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。

因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量

如果追加节点后，链表数量>=8，则转化为红黑树

由迭代器的实现可以看出，遍历HashMap时，顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。属于无序集合。

HashMap的源码中，充斥个各种位运算代替常规运算的地方，以提升效率：

• 与运算替代模运算。用(table.length-1) & hash替代(table.length) % hash
• 用if ((e.hash & oldCap) == 0)判断扩容后，节点e处于低区还是高区。

为了大家更好的理解HashMap源码，建议大家先深入了解一下 ArrayList 和 LinkedList ：

• 【手撕源码系列】ArrayList源码解读—Java8版本
• 【手撕源码系列】LinkedList源码解读—Java8版本

如果小伙伴们不了解"fail-fast"机制，可以参考如下文章：
深入浅出fail-fast机制

1.4 线程安全性

HashMap的线程不安全，HashMap中的方法都是不同步的

put方法不同
addEntry方法依然不是同步的，所以导致了线程不安全出现伤处问题，其他类似操作不再说明。

resize方法不同步
扩容过程中，会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。

当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，这样也会有问题。

如何线程安全的使用 HashMap：

• Hashtable
• ConcurrentHashMap
• Synchronized Map

为了减少这类基础问题的发生，建议使用ConcurrentHashMap替换HashMap。

<1> ConcurrentHashMap1.8之前使用segment分段锁，jdk1.8以后通过CAS算法实现无锁化，目标都是为了实现轻量级线程同步。相比HashTable性能高很多。

<2> ConcurrentHashMap没有fastfail问题，可以减少程序错误的发生。

CHM 性能是明显优于 Hashtable 和 SynchronizedMap 的,CHM 花费的时间比前两个的一半还少。

1.5 优劣分析

HashMap 树化
链表的查找性能是O(n)，若节点数较小性能不回收太大影响，但数据较大时差距将逐渐显现。树的查找性能是O(log(n))，性能优势瞬间体现

• 优点：超级快速的查询速度，如果有人问你什么数据结构可以达到O(1)的时间复杂度，没错是HashMap，动态的可变长存储数据（和数组相比较而言）

• 缺点：需要额外计算一次hash值，如果处理不当会占用额外的空间

二、定义

我们先来看看HashMap的定义：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

HashMap的类结构图：

如何查看类的完整结构图可以参考如下文章：
IDEA如何查看类的完整结构图

三、数据结构

四、域的解读

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    //序列号，序列化的时候使用。
    private static final long serialVersionUID = 362498820763181265L;
    /**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。**/
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //最大容量，2的30次方。
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //加载因子，用于扩容使用。
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    //当某个桶节点数量大于8时，会转换为红黑树。
    static final int TREEIFY_THRESHOLD = 8;
    //当某个桶节点数量小于6时，会转换为链表，前提是它当前是红黑树结构。
    static final int UNTREEIFY_THRESHOLD = 6;
    //当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
    static final int MIN_TREEIFY_CAPACITY = 64;
    //存储元素的数组，transient关键字表示该属性不能被序列化
    transient Node<K,V>[] table;
    //将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
    transient Set<Map.Entry<K,V>> entrySet;
    //元素数量
    transient int size;
    //统计该map修改的次数
    transient int modCount;
    //临界值，也就是元素数量达到临界值时，会进行扩容。
    int threshold;
    //也是加载因子，只不过这个是变量。
    final float loadFactor;  

其中最主要的成员变量：

table变量：HashMap的底层数据结构，是Node类的实体数组，Node是一个静态内部类，一种数组和链表相结合的复合结构，用于保存key-value对；

size变量：表示已存储的HashMap的key-value对的数量；

loadFactor变量：装载因子，用于衡量满的程度，默认值为0.75f（static final float DEFAULT_LOAD_FACTOR = 0.75f;）；

threshold变量：临界值，当实际KV个数超过threshold时，HashMap会将容量扩容，threshold＝容量*加载因子；

capacity：并不是一个成员变量，但却是一个必须要知道的概念，表示容量，默认容量是16(static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;)

为什么默认容量大小为16，加载因子为0.75，主要原因是这两个常量的值都是经过大量的计算和统计得出来的最优解，仅仅是这样而已。

链表节点Node

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//哈希值
        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; }
 
        //每一个节点的hash值，是将key的hashCode 和 value的hashCode 亦或得到的。
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
        //设置新的value 同时返回旧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;
        }
    }//这是一个单链表,每一个节点的hash值，是将key的hashCode 和 value的hashCode 亦或得到的。

五、构造方法

HashMap 共提供了 4 种 构造方法，满足各种常见场景下对容量的需求

	// 第1种：创建一个 HashMap 并指定 容量(initialCapacity) 和装载因子(loadFactor)
    public HashMap(int initialCapacity, float loadFactor) {
    	// 指定容量不可小于0，但可设置为 0 。之后通过put()添加元素时，会resize()
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        // 如果指定的容量超过了最大值，则自动置为最大值，也就是 1 << 30（也就是2的30次方）
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        // 装载因子不可小于等于 0 或 非数字（NaN）
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        // 初始化装载因子
        this.loadFactor = loadFactor;
        // 初始化下次需要调整到的容量（容量*装载因子）。
        this.threshold = tableSizeFor(initialCapacity);
    }

	// 第2种：创建一个指定容量的 HashMap，装载因子使用默认的 0.75
    public HashMap(int initialCapacity) {
    	// 调用上个构造方法初始化
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

	// 第3种：创建一个默认初始值的 HashMap ，容量为16，装载因子为0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

	// 第4种：创建一个 Hashmap 并将 m 内包含的所有元素存入
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

tableSizeFor(int cap)
获取一个既大于 cap 又最接近 cap 的 2 的整数次幂数值

 	// 假设 cap = 128
    static final int tableSizeFor(int cap) {
        int n = cap - 1; // 则 n = 127 = 01111111
        n |= n >>> 1; // n = 01111111 ， n >>> 1 = 00111111 ， 按位或后  n = 01111111
        n |= n >>> 2; // n = 01111111 ， n >>> 1 = 00011111， 按位或后  n = 01111111
        n |= n >>> 4; // n = 01111111 ， n >>> 1 = 00000111， 按位或后  n = 01111111
        n |= n >>> 8; // n = 01111111 ， n >>> 1 = 00000000， 按位或后  n = 01111111
        n |= n >>> 16; // n = 01111111 ， n >>> 1 = 00000000， 按位或后  n = 01111111
        // 如果 n 小于 0 则返回 1，否则判断 n 是否大于等于最大容量，是的话返回最大容量，不是就返回 n+1（也就是128）
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

六、核心方法

6.1 tableSizeFor(int cap)

获取一个既大于 cap 又最接近 cap 的 2 的整数次幂数值

 	// 假设 cap = 128
    static final int tableSizeFor(int cap) {
        int n = cap - 1; // 则 n = 127 = 01111111
        n |= n >>> 1; // n = 01111111 ， n >>> 1 = 00111111 ， 按位或后  n = 01111111
        n |= n >>> 2; // n = 01111111 ， n >>> 1 = 00011111， 按位或后  n = 01111111
        n |= n >>> 4; // n = 01111111 ， n >>> 1 = 00000111， 按位或后  n = 01111111
        n |= n >>> 8; // n = 01111111 ， n >>> 1 = 00000000， 按位或后  n = 01111111
        n |= n >>> 16; // n = 01111111 ， n >>> 1 = 00000000， 按位或后  n = 01111111
        // 如果 n 小于 0 则返回 1，否则判断 n 是否大于等于最大容量，是的话返回最大容量，不是就返回 n+1（也就是128）
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

图解：

6.2 hash() 方法

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

这个根据key取hash值的函数，称之为“扰动函数”

最开始的hashCode： 1111 1111 1111 1111 0100 1100 0000 1010
右移16位的hashCode：0000 0000 0000 0000 1111 1111 1111 1111
异或运算后的hash值： 1111 1111 1111 1111 1011 0011 1111 0101

将hashcode 与 hashcode的低16位做异或运算，混合了高位和低位得出的最终hash值（扰动算法），冲突的概率就小多了。

而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。

因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。

但就算原本的hashCode()取得很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。 即，碰撞率会增大。

扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）

6.3 put(K key, V value)

    public V put(K key, V value) {
        /**四个参数，第一个hash值，第四个参数表示如果该key存在值，如果为null的话，则插入新的value，最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可**/
        return putVal(hash(key), key, value, false, true);
    }
 
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab 哈希数组，p 该哈希桶的首节点，n hashMap的长度，i 计算出的数组下标
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**如果计算出的该哈希桶的位置没有值，则把新插入的key-value放到此处，此处就算没有插入成功，也就是发生哈希冲突时也会把哈希桶的首节点赋予p**/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //发生哈希冲突的几种情况
        else {
            // e 临时节点的作用， k 存放该当前节点的key 
            Node<K,V> e; K k;
            //第一种，插入的key-value的hash值，key都与当前节点的相等，e = p，则表示为首节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //第二种，hash值不等于首节点，判断该p是否属于红黑树的节点
            else if (p instanceof TreeNode)
                /**为红黑树的节点，则在红黑树中进行添加，如果该节点已经存在，则返回该节点（不为null），该值很重要，用来判断put操作是否成功，如果添加成功返回null**/
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //第三种，hash值不等于首节点，不为红黑树的节点，则为链表的节点
            else {
                //遍历该链表
                for (int binCount = 0; ; ++binCount) {
                    //如果找到尾部，则表明添加的key-value没有重复，在尾部进行添加
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //判断是否要转换为红黑树结构
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                        break;
                    }
                    //如果链表中有重复的key，e则为当前重复的节点，结束循环
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //有重复的key，则用待插入值进行覆盖，返回旧值。
            if (e != null) { 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //到了此步骤，则表明待插入的key-value是没有key的重复，因为插入成功e节点的值为null
        //修改次数+1
        ++modCount;
        //实际长度+1，判断是否大于临界值，大于则扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        //添加成功
        return null;
    }

6.4 resize()

      final Node<K,V>[] resize() {
    	// 把当前底层数组赋值给oldTab，为数据迁移工作做准备
        Node<K,V>[] oldTab = table;
        // 获取当前数组的大小，等于或小于0表示需要初始化数组，大于0表示需要扩容数组
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 获取扩容的阈值（容量*负载系数）
        int oldThr = threshold;
        // 定义并初始化新数组长度和目标阈值
        int newCap, newThr = 0;
        // 判断是初始化数组还是扩容，等于或小于0表示需要初始化数组，大于0表示需要扩容数组。若  if(oldCap > 0)=true 表示需扩容而非初始化
        if (oldCap > 0) {
        	// 判断数组长度是否已经是最大，MAXIMUM_CAPACITY =（2^30）
            if (oldCap >= MAXIMUM_CAPACITY) {
            	// 阈值设置为最大
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)            	
            	// 目标阈值扩展2倍，数组长度扩展2倍
                newThr = oldThr << 1; // double threshold
        }
        // 表示需要初始化数组而不是扩容
        else if (oldThr > 0) 
        	// 说明调用的是HashMap的有参构造函数，因为无参构造函数并没有对threshold进行初始化
            newCap = oldThr;
        // 表示需要初始化数组而不是扩容，零初始阈值表示使用默认值
        else {	
        	// 说明调用的是HashMap的无参构造函数
            newCap = DEFAULT_INITIAL_CAPACITY;
            // 计算目标阈值
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 当目标阈值为0时需重新计算，公式：容量（newCap）*负载系数（loadFactor）
        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;
                // 将数组内此下标中的数据赋值给Node类型的变量e，并判断非空
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    // 1 - 普通元素判断：判断数组内此下标中是否只存储了一个元素，是的话表示这是一个普通元素，并开始转移
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 2 - 红黑树判断：判断此下标内是否是一颗红黑树，是的话进行数据迁移
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 3 -  链表判断：若此下标内包含的数据既不是普通元素又不是红黑树，则它只能是一个链表，进行数据转移
                    else { // preserve order
                        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;
                            }
                            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;
    }

6.5 putAll(Map m)

往表中批量增加数据

public void putAll(Map<? extends K, ? extends V> m) {
        //将另一个Map的所有元素加入表中，参数evict初始化时为false，其他情况为true
        putMapEntries(m, true);
    }

6.6 putIfAbsent(K key, V value)

只会往表中插入 key-value, 若key对应的value之前存在，不会覆盖。（jdk8增加的方法）

 @Override
    public V putIfAbsent(K key, V value) {
        return putVal(hash(key), key, value, true, true);
    }

demo:

package com.uncle;

import java.util.HashMap;

public class Main {

    public static void main(String[] args) throws Exception {

        HashMap<Object, Object> hashMap = new HashMap<>(5);

        hashMap.put(1, null);
        hashMap.putIfAbsent(1, 2);
        System.out.println(hashMap.get(1));//2
        
        hashMap.putIfAbsent(2, 3);
        hashMap.putIfAbsent(2, 4);
        System.out.println(hashMap.get(2));//3
        
//        Class aClass = hashMap.getClass();
//        Field table = aClass.getDeclaredField("table");
//        table.setAccessible(true);
//        Object[] o = (Object[]) table.get(hashMap);
//
//        System.out.println(o.length);

    }
    
}

6.7 remove(Object key)

删除还有clear方法，把所有的数组下标元素都置位null，下面在来看看较为简单的获取元素与修改元素操作。

    public V remove(Object key) {
        //临时变量
        Node<K,V> e;
        /**调用removeNode(hash(key), key, null, false, true)进行删除，第三个value为null，表示，把key的节点直接都删除了，不需要用到值，如果设为值，则还需要去进行查找操作**/
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
    /**第一参数为哈希值，第二个为key，第三个value，第四个为是为true的话，则表示删除它key对应的value，不删除key,第四个如果为false，则表示删除后，不移动节点**/
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        //tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        //哈希数组不为null，且长度大于0，然后获得到要删除key的节点所在是数组下标位置
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            //nodee 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
            Node<K,V> node = null, e; K k; V v;
            //如果数组下标的节点正好是要删除的节点，把值赋给临时变量node
            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不再是数组下标的节点，而是要删除结点的上一个结点**/
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
            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)
                    tab[index] = node.next;
                else /**为链表结构，删除的节点在链表中，把要删除的下一个结点设为上一个结点的下一个节点**/
                    p.next = node.next;
                //修改计数器
                ++modCount;
                //长度减一
                --size;
                /**此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理**/
                afterNodeRemoval(node);
                //返回删除的节点
                return node;
            }
        }
        //返回null则表示没有该节点，删除失败
        return null;
    }

6.8 remove(Object key, Object value)

 @Override
    public boolean remove(Object key, Object value) {
        //这里传入了value 同时matchValue为true
        return removeNode(hash(key), key, value, true, true) != null;
    }

6.9 “update()”

元素的修改也是put方法，因为key是唯一的，所以修改元素，是把新值覆盖旧值。

6.10 get(Object key)

    public V get(Object key) {
        Node<K,V> e;
        //也是调用getNode方法来完成的
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
 
    final Node<K,V> getNode(int hash, Object key) {
        //first 头结点，e 临时变量，n 长度,k key
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //头结点也就是数组下标的节点
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //如果是头结点，则直接返回头结点
            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;
    }

6.11 containsKey(Object key)

判断是否包含该key

public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

6.12 containsValue(Object value)

判断是否包含value

    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        //遍历哈希桶上的每一个链表
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    //如果找到value一致的返回true
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

6.13 getOrDefault(Object key, V defaultValue)

以key为条件，找到了返回value。否则返回defaultValue

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

6.14 遍历

 //缓存 entrySet
    transient Set<Map.Entry<K,V>> entrySet;
     */
    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

    final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        //一般我们用到EntrySet，都是为了获取iterator
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
        //最终还是调用getNode方法
        public final boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Node<K,V> candidate = getNode(hash(key), key);
            return candidate != null && candidate.equals(e);
        }
        //最终还是调用removeNode方法
        public final boolean remove(Object o) {
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>) o;
                Object key = e.getKey();
                Object value = e.getValue();
                return removeNode(hash(key), key, value, true, true) != null;
            }
            return false;
        }
        //。。。
    }

  final class EntryIterator extends HashIterator
        implements Iterator<Map.Entry<K,V>> {
        public final Map.Entry<K,V> next() { return nextNode(); }
    }

    abstract class HashIterator {
        Node<K,V> next;        // next entry to return
        Node<K,V> current;     // current entry
        int expectedModCount;  // for fast-fail
        int index;             // current slot
 
        HashIterator() {
            //因为hashmap也是线程不安全的，所以要保存modCount。用于fail-fast策略
            expectedModCount = modCount;
            Node<K,V>[] t = table;
            current = next = null;
            index = 0;
            //next 初始时，指向 哈希桶上第一个不为null的链表头
            if (t != null && size > 0) { // advance to first entry
                do {} while (index < t.length && (next = t[index++]) == null);
            }
        }
 
        public final boolean hasNext() {
            return next != null;
        }
 
        //由这个方法可以看出，遍历HashMap时，顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。属于无序集合。
        final Node<K,V> nextNode() {
            Node<K,V>[] t;
            Node<K,V> e = next;
            //fail-fast策略
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            //依次取链表下一个节点，
            if ((next = (current = e).next) == null && (t = table) != null) {
                //如果当前链表节点遍历完了，则取哈希桶下一个不为null的链表头
                do {} while (index < t.length && (next = t[index++]) == null);
            }
            return e;
        }
 
        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            fail-fast策略
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            //最终还是利用removeNode 删除节点
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }

七、阿里面试实战

7.1、为什么需要散列表

HashMap中的数据结构为散列表，又名哈希表。在这里我会对散列表进行一个简单的介绍，在此之前我们需要先回顾一下 数组、链表 的优缺点。

• 数组：数组删除、插入性能不佳，寻址性能极优
• 链表：链表查询性能不佳，删除、插入性能极优

数组的优缺点取决于他们在内存中存储的模式，也就是直接使用顺序存储或链式存储导致的。无论是数组还是链表，都有明显的缺点。而在实际业务中，我们想要的往往是寻址、删除、插入性能都很好的数据结构，散列表就是这样一种结构，它巧妙的结合了数组与链表的优点，并将其缺点弱化（并不是完全消除）

7.2 能说一下HashMap的数据结构吗？

JDK1.7的数据结构是数组+链表

JDK1.8的数据结构是数组+链表+红黑树。

数据结构示意图如下：

其中，桶数组是用来存储数据元素，链表是用来解决冲突，红黑树是为了提高查询的效率。

• 数据元素通过映射关系，也就是散列函数，映射到桶数组对应索引的位置
• 如果发生冲突，从冲突的位置拉一个链表，插入冲突的元素
• 如果链表长度>8&数组大小>=64，链表转为红黑树
• 如果红黑树节点个数<6 ，转为链表

7.3 你对红黑树了解多少？为什么不用二叉树/平衡树呢？

红黑树本质上是一种二叉查找树，为了保持平衡，它又在二叉查找树的基础上增加了一些规则：

• 每个节点要么是红色，要么是黑色；
• 根节点永远是黑色的；
• 所有的叶子节点都是是黑色的（注意这里说叶子节点其实是图中的 NULL 节点）；
• 每个红色节点的两个子节点一定都是黑色；
• 从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点；
  

之所以不用二叉树：

红黑树是一种平衡的二叉树，插入、删除、查找的最坏时间复杂度都为 O(logn)，避免了二叉树最坏情况下的O(n)时间复杂度。

之所以不用平衡二叉树：

平衡二叉树是比红黑树更严格的平衡树，为了保持保持平衡，需要旋转的次数更多，也就是说平衡二叉树保持平衡的效率更低，所以平衡二叉树插入和删除的效率比红黑树要低。

7.4 红黑树怎么保持平衡的知道吗？

红黑树有两种方式保持平衡：旋转和染色。

• 旋转：旋转分为两种，左旋和右旋
• 染⾊

7.5 HashMap的put流程知道吗？

首先进行哈希值的扰动，获取一个新的哈希值。(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

判断tab是否位空或者长度为0，如果是则进行扩容操作。

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

根据哈希值计算下标，如果对应小标正好没有存放数据，则直接插入即可否则需要覆盖。tab[i = (n - 1) & hash])

判断tab[i]是否为树节点，否则向链表中插入数据，是则向树中插入节点。

如果链表中插入节点的时候，链表长度大于等于8，则需要把链表转换为红黑树。treeifyBin(tab, hash);

最后所有元素处理完成后，判断是否超过阈值；threshold，超过则扩容。

7.6 HashMap怎么查找元素的呢？

HashMap的查找就简单很多：

• 使用扰动函数，获取新的哈希值
• 计算数组下标，获取节点
• 当前节点和key匹配，直接返回
• 否则，当前节点是否为树节点，查找红黑树
• 否则，遍历链表查找

7.7 HashMap的哈希/扰动函数是怎么设计的?

HashMap的哈希函数是先拿到 key 的hashcode，是一个32位的int类型的数值，然后让hashcode的高16位和低16位进行异或操作。

static final int hash(Object key) {
    int h;
    // key的hashCode和key的hashCode右移16位做异或运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

这么设计是为了降低哈希碰撞的概率。

7.8 为什么哈希/扰动函数能降hash碰撞？

因为 key.hashCode() 函数调用的是 key 键值类型自带的哈希函数，返回 int 型散列值。int 值范围为 -2147483648~2147483647，加起来大概 40 亿的映射空间。

只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个 40 亿长度的数组，内存是放不下的。

假如 HashMap 数组的初始大小才 16，就需要用之前需要对数组的长度取模运算，得到的余数才能用来访问数组下标。

源码中模运算就是把散列值和数组长度 - 1 做一个 “与&” 操作，位运算比取余 % 运算要快。

bucketIndex = indexFor(hash, table.length);

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

顺便说一下，这也正好解释了为什么 HashMap 的数组长度要取 2 的整数幂。因为这样（数组长度 - 1）正好相当于一个 “低位掩码”。与 操作的结果就是散列值的高位全部归零，只保留低位值，用来做数组下标访问。以初始长度 16 为例，16-1=15。2 进制表示是 0000 0000 0000 0000 0000 0000 0000 1111。和某个散列值做 与 操作如下，结果就是截取了最低的四位值。

这样是要快捷一些，但是新的问题来了，就算散列值分布再松散，要是只取最后几位的话，碰撞也会很严重。如果散列本身做得不好，分布上成等差数列的漏洞，如果正好让最后几个低位呈现规律性重复，那就更难搞了。

这时候 扰动函数的价值就体现出来了，看一下扰动函数的示意图：

右移 16 位，正好是 32bit 的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。

7.9 为什么HashMap的容量是2的倍数呢？

第一个原因是为了方便哈希取余：

• 将元素放在table数组上面，是用hash值%数组大小定位位置，而HashMap是用hash值&(数组大小-1)，却能和前面达到一样的效果，这就得益于HashMap的大小是2的倍数，2的倍数意味着该数的二进制位只有一位为1，而该数-1就可以得到二进制位上1变成0，后面的0变成1，再通过&运算，就可以得到和%一样的效果，并且位运算比%的效率高得多
• HashMap的容量是2的n次幂时，(n-1)的2进制也就是1111111***111这样形式的，这样与添加元素的hash值进行位运算时，能够充分的散列，使得添加的元素均匀分布在HashMap的每个位置上，减少hash碰撞。

第二个方面是在扩容时，利用扩容后的大小也是2的倍数，将已经产生hash碰撞的元素完美的转移到新的table中去.

7.10 如果初始化HashMap，传一个17的值new HashMap<>，它会怎么处理？

简单来说，就是初始化时，传的不是2的倍数时，HashMap会向上寻找离得最近的2的倍数，所以传入17，但HashMap的实际容量是32。

我们来看看详情，在HashMap的初始化中，有这样⼀段⽅法；

public HashMap(int initialCapacity, float loadFactor) {
 ...
 this.loadFactor = loadFactor;
 this.threshold = tableSizeFor(initialCapacity);
}

• 阀值 threshold ，通过⽅法 tableSizeFor 进⾏计算，是根据初始化传的参数来计算的。
• 同时，这个⽅法也要要寻找⽐初始值⼤的，最⼩的那个2进制数值。⽐如传了17，我应该找到的是32。

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

• MAXIMUM_CAPACITY = 1 << 30，这个是临界范围，也就是最⼤的Map集合。
• 计算过程是向右移位1、2、4、8、16，和原来的数做|运算，这主要是为了把⼆进制的各个位置都填上1，当⼆进制的各个位置都是1以后，就是⼀个标准的2的倍数减1了，最后把结果加1再返回即可。

7.11 你还知道哪些哈希函数的构造方法呢？

HashMap里哈希构造函数的方法叫：

除留取余法：H（key)=key%p（p<=N）,关键字除以一个不大于哈希表长度的正整数p，所得余数为地址，当然HashMap里进行了优化改造，效率更高，散列也更均衡。
除此之外，还有这几种常见的哈希函数构造方法：

直接定址法

直接根据key来映射到对应的数组位置，例如1232放到下标1232的位置。

数字分析法

取key的某些数字（例如十位和百位）作为映射的位置

平方取中法

取key平方的中间几位作为映射的位置

折叠法

将key分割成位数相同的几段，然后把它们的叠加和作为映射的位置

7.12 解决哈希冲突有哪些方法呢？

HashMap使用链表的原因为了处理哈希冲突，这种方法就是所谓的：
链地址法：在冲突的位置拉一个链表，把冲突的元素放进去。

开放定址法：开放定址法就是从冲突的位置再接着往下找，给冲突元素找个空位。

找到空闲位置的方法也有很多种：

• 线行探查法: 从冲突的位置开始，依次判断下一个位置是否空闲，直至找到空闲位置

• 平方探查法: 从冲突的位置x开始，第一次增加1^{2个位置，第二次增加2}2…，直至找到空闲的位置 ……

• 再哈希法：换种哈希函数，重新计算冲突元素的地址。

• 建立公共溢出区：再建一个数组，把冲突的元素放进去。

7.13 为什么HashMap链表转红黑树的阈值为8呢？

树化发生在table数组的长度大于64，且链表的长度大于8的时候。

为什么是8呢？源码的注释也给出了答案。
红黑树节点的大小大概是普通节点大小的两倍，所以转红黑树，牺牲了空间换时间，更多的是一种兜底的策略，保证极端情况下的查找效率。

阈值为什么要选8呢？和统计学有关。理想情况下，使用随机哈希码，链表里的节点符合泊松分布，出现节点个数的概率是递减的，节点个数为8的情况，发生概率仅为0.00000006。

至于红黑树转回链表的阈值为什么是6，而不是8？是因为如果这个阈值也设置成8，假如发生碰撞，节点增减刚好在8附近，会发生链表和红黑树的不断转换，导致资源浪费。

7.14 扩容在什么时候呢？为什么扩容因子是0.75？

为了减少哈希冲突发生的概率，当前HashMap的元素个数达到一个临界值的时候，就会触发扩容，把所有元素rehash之后再放在扩容后的容器中，这是一个相当耗时的操作。

而这个临界值threshold就是由加载因子和当前容器的容量大小来确定的，假如采用默认的构造方法：threshold = （DEFAULT_INITIAL_CAPACITY） *（DEFAULT_LOAD_FACTOR）

那就是大于16x0.75=12时，就会触发扩容操作。

那么为什么选择了0.75作为HashMap的默认加载因子呢？

简单来说，这是对空间成本和时间成本平衡的考虑。

我们都知道，HashMap的散列构造方式是Hash取余，负载因子决定元素个数达到多少时候扩容。

假如我们设的比较大，元素比较多，空位比较少的时候才扩容，那么发生哈希冲突的概率就增加了，查找的时间成本就增加了。

我们设的比较小的话，元素比较少，空位比较多的时候就扩容了，发生哈希碰撞的概率就降低了，查找时间成本降低，但是就需要更多的空间去存储元素，空间成本就增加了。

7.15 扩容机制了解吗？

HashMap是基于数组+链表和红黑树实现的，但用于存放key值的桶数组的长度是固定的，由初始化参数确定。

那么，随着数据的插入数量增加以及负载因子的作用下，就需要扩容来存放更多的数据。而扩容中有一个非常重要的点，就是jdk1.8中的优化操作，可以不需要再重新计算每一个元素的哈希值。

因为HashMap的初始容量是2的次幂，扩容之后的长度是原来的二倍，新的容量也是2的次幂，所以，元素，要么在原位置，要么在原位置再移动2的次幂。

看下这张图，n为table的长度，图a表示扩容前的key1和key2两种key确定索引的位置，图b表示扩容后key1和key2两种key确定索引位置。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

所以在扩容时，只需要看原来的hash值新增的那一位是0还是1就行了，是0的话索引没变，是1的化变成原索引+oldCap，看看如16扩容为32的示意图：

7.16 jdk1.8对HashMap主要做了哪些优化呢？为什么？

jdk1.8 的HashMap主要有五点优化：

数据结构：数组 + 链表改成了数组 + 链表或红黑树

原因：发生 hash 冲突，元素会存入链表，链表过长转为红黑树，将时间复杂度由O(n)降为O(logn)

链表插入方式：链表的插入方式从头插法改成了尾插法

简单说就是插入时，如果数组位置上已经有元素，1.7 将新元素放到数组中，原始节点作为新节点的后继节点，1.8
遍历链表，将元素放置到链表的最后。

原因：因为 1.7 头插法扩容时，头插法会使链表发生反转，多线程环境下会产生环。

扩容rehash：扩容的时候 1.7 需要对原数组中的元素进行重新 hash 定位在新数组的位置，1.8
采用更简单的判断逻辑，不需要重新通过哈希函数计算位置，新的位置不变或索引 + 新增容量大小。

原因：提高扩容的效率，更快地扩容。

扩容时机：在插入时，1.7 先判断是否需要扩容，再插入，1.8 先进行插入，插入完成再判断是否需要扩容；

散列函数：1.7 做了四次移位和四次异或，jdk1.8只做一次。

原因：做 4 次的话，边际效用也不大，改为一次，提升效率。

---

推荐阅读：Java小白进阶架构师学习路线

---