HashMap源码笔记(jdk8)
个人看源码的笔记记录，基于JDK8。
数据结构图：
一、HashMap的成员变量
关注一下成员变量Node
//table数组默认初始化容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//table数组最大容量2^ 30 次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认值0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树形阈值：JDK 1.8 新增的，当使用 树 而不是 链表 作为桶的数据结构时使用
static final int TREEIFY_THRESHOLD = 8;
//非树形阈值：也是 1.8 新增的，扩容时分裂一个树形桶的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//树形最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 实际存放数据的成员变量table，就是一个Node数组，即HashMap就是用Node数组来存取数据的。
* HashMap数据结构=数组+单链表(链表长度超过8变成二叉树),Node如何形成单链表见后面分析
*/
transient Node[] table;
//缓存的 键值对 集合
transient Set> entrySet;
//当前存储的键值对数量
transient int size;
/**
* HashMap改变的次数
* HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化（比如put，remove等操作），会抛出异常ConcurrentModificationException
*/
transient int modCount;
/**
* 阈值，(capacity * load factor)，size > threshold时resize(扩容)
* 若table数组未初始化，threshold = table数组默认长度 = 0 (table数组初始化是在第一次put()时，HashMap构造函数中并没有初始化table数组，put()方法会对threshold重新计算)
*/
int threshold;
//负载因子，主要用来计算threshold值的
final float loadFactor; 二、HashMap的静态内部类Node
成员变量Node
//节点类：HashMap实际存放键值对数据的地方，实现了Map.Entry接口
static class Node implements Map.Entry {
final int hash;//K的hash值，存储起来不用重复计算
final K key;//键
V value;//值
Node next;//下一个节点对象的引用，所以Node对象才能在内部形成桶式单链表结构
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; }
/**
* 键的hashcode ^ 值的hashcode
* 让值也参与Node的hashCode计算是因为key的hash冲突，即不同key的hashCode可能相同，这时候就需要引入value的hashCode来唯一确定Node对象
* 参考Object的“重写equals()方法也需要重写hashCode()方法”
*/
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;
}
} 三、HashMap的4个构造函数
//指定初始容量与负载因子构建HashMap
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;
//这里可发现，构造函数并没有直接初始化table数组，只是给阈值threshold赋值了（table数组初始化是在第一次put()时）
this.threshold = tableSizeFor(initialCapacity);
}
//指定初始容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);//负载因子默认0.75
}
//最常用的构造函数，只是指定了负载因子使用0.75，其他字段保持编译器赋予的默认值
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//用Map构造一个负载因子为0.75的新HashMap
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//将Map中数据放入新构建的HashMap中
putMapEntries(m, false);
}HashMap(int initialCapacity, float loadFactor)的最后一行：this.threshold = tableSizeFor(initialCapacity);注意一下，初始化了threshold值，而没有初始化table数组 。
所有构造函数都没有初始化table数组，table数组初始化是在第一次put()时（懒加载思想吧：在真正用到的时候才会去初始化），第一次put()时也会给阈值threshold 重新赋值。
四、HashMap的成员变量threshold的初始化函数tableSizeFor
/**
* 返回一个比指定容量大且最接近的2的幂次方整数（HashMao要求容量必须为2的幂次方）
* 例如：cap=10，return 的就是2^4=16
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;//位运算，无符号右移1位、再与右移前的值或运算一次
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}是一个十分巧妙的算法，使用位运算效率高，目的就是为了得到比指定容量大且最接近的2的幂次方整数，HashMap要求table数组大小必须为2的幂次方，至于为啥这样要求，有的说扩容时也使用2的幂次方可减少key的hash碰撞，了解不深。
五、构造函数HashMap(Map m)
//将Map中数据放入新的HashMap中
final void putMapEntries(Map m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
//迭代Map
for (Map.Entry e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//调用HashMap.putVal()方法，将Map的key、value放入HashMap中
putVal(hash(key), key, value, false, evict);
}
}
}可发现最后调用的还是HashMap.putVal()方法，将Map的key、value放入新的HashMap中。
六、Node对象key的hash值计算函数
/**
* key的hash值计算：将传入键的 hashCode 进行无符号右移 16 位，然后进行按位异或，得到这个键的哈希值。
* 由于哈希表的容量都是 2 的 N 次方，在当前，元素的 hashCode() 在很多时候下低位是相同的，这将导致冲突（碰撞），因此 1.8 以后做了个移位操作：将元素的 hashCode() 和自己右移 16 位后的结果求异或。
* int 4字节 32 位，无符号右移 16 位相当于把高位的一半移到低位。即让高16位也参与key的hash值计算中。这样可以避免只靠低位数据来计算哈希时导致的冲突，计算结果由高低位结合决定，可以避免哈希值分布不均匀。
* HashMap中table下标的计算：
* table数组下标i = (table.length - 1) & key的hash值
* 假设table.length=2^4=16，分析后可发现，hash值只有低4位参与了下标计算。
* 这样做很容易产生碰撞。仅仅异或一下，既减少了系统的开销，也不会造成的因为高位没有参与下标的计算从而引起的碰撞
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}七、HashMap.put()
put()执行流程图：
源码：
//往HashMap put数据
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[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
//初始化table数组,通过resize()的方式
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//table数组下标i = (table数组length - 1) & key的hash值
tab[i] = newNode(hash, key, value, null);//tab[i]==null，当前位置为空，直接创建一个新Node对象赋予tab[i]
else {
//tab[i] != null，当前位置已有Node对象
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//key已存在，用新值覆盖旧值（赋值e.value = value是在后面进行的，这里只是将旧Node赋给新Node对象）
e = p;
else if (p instanceof TreeNode)
//key不存在且旧Node属于TreeNode类型，放入树形二叉树中
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
//key不存在且旧Node不属于TreeNode类型，即链表类型
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//旧Node 的next为空，即没有下一个元素
p.next = newNode(hash, key, value, null);//创建Node赋给旧Node的next属性
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//0-7,循环判断次数 >= 8，加上新加的Node即链表长度超过8时，将链表tab转换为二叉树
treeifyBin(tab, hash);
break;//结束循环
}
//旧Node 的next不为空
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//key已存在，退出循环
break;
/**
* 将旧Node 的next赋予旧Node，继续循环判断Node.next是否为空.
* 所以查找单链表中Node.next为空的节点需要遍历整个链表，当链表数据量变大时效率低下.
* jdk1.8前HashMap数据结构=数组+单链表
* jdk1.8后HashMap数据结构=数组+单链表(链表长度超过8转换为二叉树)，引入二叉树加快Node.next为空节点的查询(只需遍历一半的节点)
*/
p = e;
}
}
if (e != null) { // existing mapping for key
//新Node不为空
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//给新Node赋值value
e.value = value;
afterNodeAccess(e);
return oldValue;//返回旧值，函数结束
}
}
//tab[i]==null,创建新Node对象赋予tab[i]后
++modCount;//每次修改HashMap数据结构modCount自增，例如：新增、删除
if (++size > threshold)
//当前存储的键值对数量>=阈值，执行扩容
resize();
afterNodeInsertion(evict);
return null;
} put()对象时，newNode()创建新节点代码：
Node newNode(int hash, K key, V value, Node next) {
return new Node<>(hash, key, value, next);
} 很易懂，就是直接去new Node。
八、HashMap.resize()
//扩容。table数组初始化也是通过resize()执行的
final Node[] resize() {
Node[] oldTab = table;//记录旧table
int oldCap = (oldTab == null) ? 0 : oldTab.length;//旧容量
int oldThr = threshold;//旧阈值
int newCap, newThr = 0;//新容量、新阈值初始化0
if (oldCap > 0) {
//旧容量 > 0，即已初始化过
if (oldCap >= MAXIMUM_CAPACITY) {
//旧容量 >= 最大容量限制，阈值赋值Integer.MAX_VALUE，这样以后就不会自动扩容了
threshold = Integer.MAX_VALUE;
return oldTab;//返回旧数组
}
//新容量=旧容量*2，位运算效率高
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新容量没有达到最大容量限制且旧容量>=16，新阈值=旧阈值*2
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//新容量=旧阈值。旧容量<=0(table未初始化)且旧阈值>0(构造函数中：this.threshold = tableSizeFor(initialCapacity)).
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//旧容量<=0(table未初始化)且旧阈值<=0。HashMap()无参构造函数：oldTab(table)表为空，oldCap=0，oldThr=0。
newCap = DEFAULT_INITIAL_CAPACITY;//新容量初始化为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新阈值=16*0.75=12
}
//新阈值=0
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数组出来
Node[] newTab = (Node[])new Node[newCap];
table = newTab;//新数组赋予对象当前table
//旧数组不为空时
if (oldTab != null) {
//将旧数组中元素reHash到新数组中
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//节点是单节点，直接计算数组下标放入数组中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//节点是TreeNode，使用红黑树的rehash操作
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
//节点是链表类型，使用链表的rehash
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;//返回新数组
} 扩容时链表的resize可参照下图，来源（侵权删）：https://www.jianshu.com/p/ee0de4c99f87
重新计算容量，计算出所需容器的大小之后重新定义一个新的容器，将原来容器中的元素放入其中。
什么时候扩容：通过HashMap源码可以看到是在put操作时，即向容器中添加元素时，当前容器中元素的个数达到阈值（当前数组长度乘以加载因子的值）的时候，就会触发扩容了。