【底层学习】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的幂的结果，并赋给成员变量thresholdthis.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方法

流程图：
在这里插入图片描述
思路：

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

在这里插入图片描述

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

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 1sttreeifyBin(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 keyV 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);}}// 找不到返回nullreturn 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