面试必问究极重点之HashMap的底层原理

1.底层数据结构

        JDK版本不同的数据结构

• 1.7 数组 + 链表

• 1.8 数组 + （链表 | 红黑树）

2.添加数据put

1. 在添加一个值的时候，首先会计算他的hash码，然后进行二次hash，在对当前长度取模得到在底层数组中的索引位置
2. 当取模完成后，会遇到不同元素索引位置相同的情况。我们把这种情况叫做hash冲突，此时会将后一个元素通过链表的形式挂在下边
3. 当存储元素数量超过数组容量的四分之三时，会进行扩容,扩容后，也可以减少链表长度。
4. 但是如果同一条链上的元素原始hash本就相同，此时通过扩容就不能有减少链表的长度了

3.树化与退化

树化意义

• 红黑树用来避免 DoS 攻击，防止链表超长时性能下降，树化应当是偶然情况，是保底策略

• hash 表的查找，更新的时间复杂度是 $O(1)$，而红黑树的查找，更新的时间复杂度是 $O(log_2⁡n )$，TreeNode 占用空间也比普通 Node 的大，如非必要，尽量还是使用链表

• hash 值如果足够随机，则在 hash 表内按泊松分布，在负载因子 0.75 的情况下，长度超过 8 的链表出现概率是 0.00000006，树化阈值选择 8 就是为了让树化几率足够小

• 

树化规则

• 当链表长度超过树化阈值 8 时，先尝试扩容来减少链表长度，如果数组容量已经 >=64，才会进行树化

退化规则

• 情况1：在扩容时如果拆分树时，树元素个数 <= 6 则会退化链表

• 情况2：remove 树节点时，若 root、root.left、root.right、root.left.left 有一个为 null ，也会退化为链表（在移除之前检查

4.索引计算

索引计算方法

• 首先，计算对象的 hashCode()

• 再进行调用 HashMap 的 hash() 方法进行二次哈希

  • 二次 hash() 是为了综合高位数据，让哈希分布更为均匀

• 最后 & (capacity – 1) 得到索引

数组容量为何是 2 的 n 次幂

1. 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模

2. 扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap

注意

• 二次 hash 是为了配合 容量是 2 的 n 次幂 这一设计前提，如果 hash 表的容量不是 2 的 n 次幂，则不必二次 hash

• 容量是 2 的 n 次幂 这一设计计算索引效率更好，但 hash 的分散性就不好，需要二次 hash 来作为补偿，没有采用这一设计的典型例子是 Hashtable

5.put与扩容

put 流程

1. HashMap 是懒惰创建数组的，首次使用才创建数组

2. 计算索引（桶下标）

3. 如果桶下标还没人占用，创建 Node 占位返回

4. 如果桶下标已经有人占用

   1. 已经是 TreeNode 走红黑树的添加或更新逻辑

   2. 是普通 Node，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑

5. 返回前检查容量是否超过阈值，一旦超过进行扩容

1.7 与 1.8 的区别

1. 链表插入节点时，1.7 是头插法，1.8 是尾插法

2. 1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容

3. 1.8 在扩容计算 Node 索引时，会优化

扩容（加载）因子为何默认是 0.75f

        当扩容的个数 > 数组长度*负载因子的值

1. 在空间占用与查询时间之间取得较好的权衡

2. 大于这个值，空间节省了，但链表就会比较长影响性能

3. 小于这个值，冲突减少了，但扩容就会更频繁，空间占用也更多

6.多线程下HashMap会有什么问题

• 扩容死链（1.7
  • 出现这个问题的主要原因是，在多线程情况下，扩容时，需要把元素从新放入新数组中，那么在同一位置上的元素会顺序放入新数组中，1.7采用的是头插法从而导致了扩容死链问题。
• 数据错乱（1.7 1.8

        多个线程同时操作HashMap会出现，数据丢失的情况，是因为在添加元素时，可能在同一位置需要添加多个元素，但是会出现覆盖情况。

7.key 的设计

        key 的设计要求

1. HashMap 的 key 可以为 null，但 Map 的其他实现则不然

2. 作为 key 的对象，必须实现 hashCode 和 equals，并且 key 的内容不能修改（不可变）如果key是可变的，那么你在HashMap去查询时，它的HashCode就不一样了，也就找不到数据了。

3. key 的 hashCode 应该有良好的散列性

        

        String 对象的 hashCode() 设计

• 目标是达到较为均匀的散列效果，每个字符串的 hashCode 足够独特

• 字符串中的每个字符都可以表现为一个数字，称为 S_i，其中 i 的范围是 0 ~ n - 1

• 散列公式为： S_0∗31^{(n-1)}+ S_1∗31^{(n-2)}+ … S_i ∗ 31^{(n-1-i)}+ …S_{(n-1)}∗31^0

• 31 代入公式有较好的散列特性，并且 31 * h 可以被优化为

  • 即 32 ∗h -h 

  • 即 2^5 ∗h -h

  • 即 h≪5 -h

8.源码分析

8.1常量

    //默认初始容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
    //最大容纳数
    //最大容量，如果使用参数的任一构造函数隐式指定了较高的值，则使用该容量。必须是 2 的幂<= 1<<30。
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //负载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //使用树而不是列表的箱计数阈值。将元素添加到至少具有此多个节点的图格时，图格将转换为树。该值必须大于 2，并且应至少为 8，以与树木移除中关于在收缩时转换回普通条柱的假设相吻合。
    //阈值 作用于 树化
    static final int TREEIFY_THRESHOLD = 8;

    //取消树化阈值
    static final int UNTREEIFY_THRESHOLD = 6;


    //最小树化容量  
    static final int MIN_TREEIFY_CAPACITY = 64;

在成员变量中可以发现

        HashMap定义了默认的初始容量、负载因子、树化阈值、退出树化阈值、最小树化数组的容量以及最大容量

8.2成员变量

    //该表在首次使用时初始化，并根据需要调整大小。分配时，长度始终是 2 的幂。（我们还允许在某些操作中使用长度为零，以允许当前不需要的引导机制。
    transient Node[] table;

 

    //保存缓存的 entrySet（）。请注意，AbstractMap 字段用于 keySet（） 和 values（）。
    transient Set> entrySet;


    //此映射中包含的键值映射数。
    transient int size;


    //此 HashMap 在结构上被修改的次数 结构修改是指更改 HashMap 中的映射数量或以其他方式修改其内部结构（例如，重新哈希）的修改。此字段用于使 HashMap 的 Collection-views 上的迭代器快速失败。（请参阅 ConcurrentModificationException）。
    transient int modCount;

    //要调整大小的下一个大小值（容量 * 负载系数）。
    int threshold;
    
    //哈希表的负载因子
    final float loadFactor;

8.3构造函数

/** 
构造一个具有指定初始容量和负载因子的空 HashMap。
参数： 
initialCapacity – 初始容量 
loadFactor – 负载系数
 抛出： IllegalArgumentException – 如果初始容量为负或负载系数为非正
*/

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

/**
构造一个空的 HashMap，具有指定的初始容量和默认负载系数 （0.75）。
参数： initialCapacity – 初始容量。
抛出：IllegalArgumentException – 如果初始容量为负数。
*/
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

//使用默认初始容量 （16） 和默认负载系数 （0.75） 构造一个空的 HashMap。
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 所有其他字段默认
    }

/**
使用与指定 Map 相同的映射构造新的 HashMap。
HashMap 是使用默认负载系数 （0.75） 创建的，初始容量足以在指定的 Map 中保存映射。
参数： m – 其映射将放置在此映射中的映射 
Throws： NullPointerException – 如果指定的映射为 null
*/

//参数时一个Map集合的话，就直接添加进去
public HashMap(Map m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

8.4get

/*
返回指定键映射到的值，如果此映射不包含键的映射，则返回 null。
更正式地说，如果此映射包含从键 k 到值 v 的映射，
使得 （key==null ？ k==null ： key.equals（k）），则此方法返回 v;
否则，它将返回 null。（最多可以有一个这样的映射。
返回值 null 并不一定表示映射不包含键的映射;
映射也有可能将键显式映射到 null。containsKey 操作可用于区分这两种情况。
参见：put（Object， Object）
**/


public V get(Object key) {
        Node e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

8.5put

//参数为 key，value 的形式 
public V put(K key, V value) {
        //调用了putVal方法
        return putVal(hash(key), key, value, false, true);
    }


/*
参数： hash – 键键的哈希值 – 键值 – 要放置的值
       onlyIfAbsent – 如果为 true，则不更改现有值 
       evict – 如果为 false，则表处于创建模式。

这个函数实现了Java中的Map的put方法及其相关方法。
它根据给定的键和值，将键值对添加到Map中。
如果键已存在且onlyIfAbsent为true，则不更改现有的值。
如果evict为false，则表处于创建模式。如果evict为true且表已满，则会清理最久未访问的键值对。
最后，该函数会调整Map的大小并返回旧的值。
**/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

8.6Node

static class Node implements Map.Entry {
        final int hash;
        final K key;
        V value;
        Node next;

        Node(int hash, K key, V value, Node 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;
        }
    }