【底层学习】HashMap源码学习

成员变量

// 默认初始容量 就是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认加载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 树化阈值（链表转为树的阈值）
static final int TREEIFY_THRESHOLD = 8;

// 取消树化阈值（红黑树转为链表）
static final int UNTREEIFY_THRESHOLD = 6;

// 链表转红黑树的数组长度的临界值 
static final int MIN_TREEIFY_CAPACITY = 64;

// hashmap中的数组结构
transient Node<K,V>[] table;

// HashMap中的元素个数
transient int size;

// HashMap被修改的次数
transient int modCount;

// 要调整大小的下一个大小值，计算公式是（容量 * 加载因子）。
int threshold;

// 实际的加载因子
final float loadFactor;

注意：
JDK1.7 及以前：HashMap 底层是数组+链表
JDK1.8 之后：HashMap 底层是数组+链表 或者 数组+红黑树
存储在 HashMap 集合中的元素都将是一个 Map.Entry 的内部接口的实现
什么时候采用数组+链表，什么时候采用数组+红黑树，以及相互转换，取决于链表(红黑树)的长度。当链表长度大于 8 会转为红黑树，当链表长度小于 6，红黑树转为链表。

构造函数

注意：以下部分是基于JDK1.8进行编写的

空参构造

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

有一个参数的构造函数

构造一个空的 HashMap ，具有指定的初始容量和默认负载系数 （0.75）。

public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

有两个参数的构造函数

构造一个具有指定初始容量和负载因子的空 HashMap

public HashMap(int initialCapacity, float loadFactor) {
    // 初始化容量小于0，错误
    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;
    //调用tableSizeFor方法计算出不小于initialCapacity的最小的2的幂的结果，并赋给成员变量threshold
    this.threshold = tableSizeFor(initialCapacity);
}

tableSizeFor 方法计算源码如下：

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

有一个Map类型参数的构造方法

public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    // 调用PutMapEntries()来完成HashMap的初始化赋值过程
    putMapEntries(m, false);
}

putMapEntries 方法调用了HashMap的resize()扩容方法和putVal()存入数据方法

HashMap 中的方法

put方法

流程图：

思路：

1. 第一次 put 会先进行扩容
2. 找到要插入的位置
   2.1. 这个位置没值：直接插入
   2.2. 这个位置有值：
   2.2.1. 判断是否 key 存在，存在的话覆盖 value
   2.2.2. 不存在，判断是否红黑树
   2.2.2.1. 如果是红黑树：调用树化插值方法
   2.2.2.2. 如果是链表：加到链表尾部，判断转树阈值，大于 8 转为红黑树
3. 判断长度是否满足扩容（长度*扩容因子）？若满足，则动态扩容

源码如下：代码大部分都标有注释，有些代码需要反复阅读可能会理解的更好

public V put(K key, V value) {
    return 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;
    // 第一次 put 值的时候，会触发下面的 resize()，类似 java7 的第一次 put 也要初始化数组长度
    // 第一次 resize 和后续的扩容有些不一样，因为这次是数组从 null 初始化到默认的 16 或自定义的初始容量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 找到具体的数组下标，如果这个位置没有值的话，就直接在这个位置初始化node放在这里就好了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else { // 走到这里说明这个位置有值
        Node<K,V> e; K k;
        // 如果插入的key一样，并且hash值也相等，如果是，取出这个节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果该节点是代表红黑树的节点，调用红黑树的插值方法
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 走到这，说明数组该位置上是一个链表
            for (int binCount = 0; ; ++binCount) {
                // 插入到链表的最后面(Java7 是插入到链表的最前面)
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // TREEIFY_THRESHOLD 为 8，所以，如果新插入的值是链表中的第 8 个
                    // 会触发下面的 treeifyBin，也就是将链表转换为红黑树
                    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;
}

resize方法

思想：用于初始化数组或数组扩容，每次扩容后，容量为原来的 2 倍，并进行数据迁移。

流程图：

get方法

源码如下：

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

final Node<K,V> getNode(int hash, Object 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 && // always check first node
            ((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);
        }
    }
    // 找不到返回null
    return null;
}

常问面试题

HashMap的key可以为 null 嘛？

可以，具体源码如下：

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

当 key 为 null 的时候，hash 值为 0，所以这也是为什么 hashmap 只允许一个 key 为 null

hash 方法的实现及为什么这样实现？

参考上面源码，这样做原因是为了减少高位没有参与下标的计算从而引起的碰撞。

为什么要用异或运算符？

保证了对象的 hashCode 的 32 位值只要有一位发生改变，整个 hash() 返回值就会改变。尽可能的减少碰撞

拉链法导致链表过深问题为什么不用二叉查找树代替，而选择红黑树？为什么不一直使用红黑树？

二叉查找树在特殊情况下会变成一条线性结构（也就是单腿树，这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。红黑树的话，会进行左旋，右旋，变色等操作来保持平衡。引入红黑树就是为了查找数据快，解决链表查询深度的问题

HashMap 存取数据的时间复杂度

不管插入还是查找，由 key 获取 hash 定位到桶的时间复杂度都是 O(1)。
如果桶里面没有元素，那么时间复杂度就是 O(1)。
若有元素，是链表，就要遍历查询，时间复杂度 O(n)，如果是红黑树，那么时间复杂度就是 O(logn)。

参考链接：https://blog.csdn.net/LoveMyTail/article/details/107286727

HashMap寻址算法

计算对象的hashCode()，在调用hash()方法进行二次哈希，hashCode值右移16位再异或运算，让哈希分布更为均匀，最后(capacity-1)&hash计算得到索引

为什么HashMap数组长度一定是2的次幂？

计算索引时效率更高：如果是2的n次幂可以使用位与运算代替取模运算
扩容时重新计算索引效率更高：hash & oldCap == 0的元素留在原位置，否则新位置 = 旧位置 + oldCap