最详细HashMap底层详解(附常见面试题)

Map家族

先来看看HashMap在Map这个大家族中的位置。

这四种比较常见：HashMap , Hashtable , LinkedHashMap，TreeMap
HashMap存取速度快，它根据键的hashcode值存储数据，线程不安全，只有一个键允许为null，对值没有限制，对数据进行遍历的话读取的随机的。如果想要同步，可以用Collections的synchronizedMap方法使HashMap线程安全或者使用ConcurrentHashMap。
Hashtable和HashMap相似，但是线程安全，存取速度相对于Hashmap较慢，键和值都不能为null。Hashtable不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换。
LinkedHashMap是HashMap的子类，保存了数据存入的先后顺序，当用Iterator遍历的时候按照存入的先后顺序进行遍历。
TreeMap对键进行排列，当用Iterator遍历的时候默认按照键的升序进行。

哈希冲突

HashMap是使用哈希表来存储的。当我们要新增或查找某个元素，就把当前元素的关键字通过哈希函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。而哈希冲突就是两个不同的元素，通过哈希函数计算后得出的实际存储地址相同。或者说，当我们对某个元素进行哈希运算后得到一个存储地址，然而要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突。为解决冲突问题，可以采用开放地址法和链地址法等，在Java中HashMap采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组中都一个链表结构，当数据被哈希函数计算后，就得到数组下标，把数据放在对应下标元素的数组中，如果数组中已经有元素，就转变为链表存在已存在的数据后面。哈希函数十分重要，好的哈希函数要把不同的键计算出来的结果十分分散的分布，分散的越均匀，发生Hash碰撞的概率就越小，map的存取效率就会越高，存储空间的利用率越好。

HashMap源码分析

HashMap的结构

HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。数组的长度一定是2的次幂。

//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

Entry是HashMap中的一个静态内部类。代码如下：

    static class Entry<K,V> implements Map.Entry<K,V> {
   
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
   
            value = v;
            next = n;
            key = k;
            hash = h;
        } 

所以，HashMap的总体结构如下：

也就是说，HashMap = 数组(位桶) + 链表 ， 数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到这个hash值对应的数组后面，但是形成了链表。同一各链表上的Hash值是相同的，所以说数组存放的是链表。在JDK1.8之后，当链表长度太长时(阈值为8)，链表就转换为红黑树，这样大大提高了查找的效率，也就是HashMap = 数组(位桶) + 链表 + 红黑树。

初始化

执行构造函数，当我们看到这个new，第一反应应该是这货又在堆内存里开辟了一块空间。

Map<String,String> map = new HashMap<>();

空参构造函数：

public HashMap() {
   
        this.loadFactor = DEFAULT_LOAD_FACTOR;
}

里面初始化了一个负载因子，值为0.75，负载因子乘上当前的容量等于阈值。HashMap有4个构造器，其他构造器如果用户没有传入initialCapacity 和loadFactor这两个参数，会使用默认值，以下是默认值：

	默认的桶数组大小
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //极限值（超过这个值就将threshold修改为Integer.MAX_VALUE（此时桶大小已经是2的31次方了），表明不进行扩容了）
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //负载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 从JDK1.8，当链表长度超过8就变为红黑树（并且hashmap中数据总数小于64）
    static final int TREEIFY_THRESHOLD = 8;
    // 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表
    static final int UNTREEIFY_THRESHOLD = 6;
    //在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化
    static final int MIN_TREEIFY_CAPACITY = 64;

这些参数对应的变量：

/**实际存储的key-value键值对的个数*/
transient int size;

/**阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，
threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/
int threshold;

/**负载因子，代表了table的填充度有多少，默认是0.75
加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。
所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
*/
final float loadFactor;

/**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，
如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
需要抛出异常ConcurrentModificationException*/
transient int modCount;

其中一个构造方法：

public HashMap(int initialCapacity, float loadFactor) {
   
　　　　　//此处对传入的初始容量进行校验，最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
        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;
        threshold = initialCapacity;
　　　　　
        init();//init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
    }

从上面这段代码我们可以看出，在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组。

put存储数据

jdk1.7中的put方法：

public V put(K key, V value) {
   
        //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold，
        //此时threshold为initialCapacity 默认是1<<4(24=16)
        if (table == EMPTY_TABLE) {
   
            inflateTable(threshold);
        }
       //如果key为null，存储位置为table[0]或table[0]的冲突链上
        if (key