HashMap源码分析
目录
参考文章：
https://zhuanlan.zhihu.com/p/95156642
https://blog.csdn.net/woshimaxiao1/article/details/83661464
一、HashMap
1、概述
（1）数据的物理存储结构只有两种
- 顺序存储
- 链式存储
栈，队列，树，图等数据结构是从逻辑结构中抽象出来，映射到内存中
（2）数组
采用一段连续的内存空间来存储数据，占用内存严重
特点：寻址容易，插入和删除困难
（3）链表
存储区间离散，占用内存比较宽松
特点：寻址困难，插入和删除容易
（4）哈希表
能否综合两者的特性，做出一种寻址容易，插入和删除也容易的数据结构？——哈希表
哈希表：也叫散列表（Hash Table），根据键（Key）而直接访问在内存存储位置的数据结构，即通过计算一个关于键值的函数，将所需查询的数据映射到表中的一个位置来访问记录，这个映射函数称为散列函数（哈希函数），存放记录的数组称为散列表（哈希表）
-
哈希表：是一个数据结构，本质是一个数组
-
键（Key）：根据Key访问数据
-
哈希函数：把元素的关键字通过哈希函数映射到数组中的某个位置——确定存储地址
-
桶（bucket）：存储位置
-
键值对：相互映射的两个值
- 键（Key）：key --> 哈希函数 --> 存储地址，如学号：101011
- 值（value）：键对应的数据，如学号101011对应姓名：张三
- Key-value：为键值对，在Java中键值对叫Entry
（5）哈希冲突
两个不同的元素，通过哈希函数的计算得出了相同的实际存储地址，这就是哈希冲突
解决方法：
- 开放寻址法：发生冲突，继续寻找下一块未被占用的地址
- 拉链法：数组+链表——可以理解为链表的数组
当通过哈希函数计算得到的地址被占用，将新元素以链表的形式放在老元素的后面，则此时的Entry中还有一个执行后一元素的next指针
2、数据结构
数组 + 链表或数组 + 红黑树
-
数组为
transient Node<K,V>[] table;：table数组称为哈希桶 -
transient：transient关键字表示该属性不能被序列化
-
Node：
static class Node<K,V> implements Map.Entry<K,V>Node对象用来存储Entry即key，value，hash和next
-
流程：key——》通过hashCode()计算出hash值得到索引i——》找到table[i]，存入
-
可能遇到的问题
- 数组的扩容——resize()
- 哈希函数——hashCode()
- 链表和树的转换——Node类、TreeNode类
二、源码分析
1、继承结构
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
（1）继承
- AbstractMap：继承一个抽象的实现了Map接口的类，Map实现部分共用的Map接口，使代码简洁，复用性高
（2）接口
-
Serialzable接口：实现该序列化接口，表明该类可以被序列化
-
Cloneable接口：可以使用Object.Clone方法，该方法可以克隆
-
Map接口：用于存储键值对的集合类
其父类AbstractMap已经实现了Map接口，这个操作是多余的
2、属性
- 容量指的是数组容量
//版本号
private static final long serialVersionUID = 362498820763181265L;
//默认数组初始容量——16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//数组最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子——超出负载因子所代表的链表长度会对哈希表进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表元素长度大于8，将链表变成树
static final int TREEIFY_THRESHOLD = 8;
//小于6从红黑树转为链表
static final int UNTREEIFY_THRESHOLD = 6;
//当table长度超过64时，哈希桶才能树形化
static final int MIN_TREEIFY_CAPACITY = 64;
//存放元素的数组，transient关键字表示该属性不能被序列化
transient Node<K,V>[] table;
//将数据转换成set的另一种存储方式，这个变量主要用于迭代功能
transient Set<Map.Entry<K,V>> entrySet;
//HashMap中键值对的数量，即元素数量
transient int size;
//记录修改次数
transient int modCount;
//阈值（临界值），调整扩容大小
int threshold;
//哈希表的负载因子变量
final float loadFactor;
3、内部类
（1）Node——单向链表
- 静态内部类：方便调用
- 单向链表
static class Node<K,V> implements Map.Entry<K,V> {
//四个属性：哈希值，key，value，和指向下一个Node对象的指针
final int hash;
final K key;
V value;
Node<K,V> next;
//构造器
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
//getXxx()方法
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
//hashCode():int——重写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;
}
//重写equals，同时复写equals方法和hashCode方法，而不要只写其中一个
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;
}
}
hashCode(Object):int——哈希方法计算哈希值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
（2）TreeNode——红黑树
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; //指向父节点
TreeNode<K,V> left;//左子节点
TreeNode<K,V> right;//右子节点
TreeNode<K,V> prev;//
boolean red;
//构造器，父类的构造器
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
...
}
上面这两个内部类再加上之前的Node<K,V>[] table属性，组成了hashMap的结构，哈希桶
4、构造器
（1）无参构造器
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
构造一个空的HashMap，默认初始容量为16，默认负载因子为0.75
（2）HashMap(int)——提供初始化容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);//传递默认负载因子
}
调用HashMap(int, float)，构造一个空的HashMap，具有指定的初始容量和默认负载因子
（3）HashMap(int, float)——提供初始化容量和负载因子
public HashMap(int initialCapacity, float loadFactor) {//传入初始化容量和负载因子
//判断初始化容量是否小于0
if (initialCapacity < 0)
//小于0抛出异常
throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
//判断是否大于最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
//初始化容量超出最大容量，则给能给的最大容量
initialCapacity = MAXIMUM_CAPACITY;
//如果负载因子小于等于0，或负载因子不是一个数值，抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//定义初始容量和负载因子
this.loadFactor = loadFactor;//负载因子
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor(int):int——返回大于cap值的，且离其最近的2次幂，例如t为29，则返回的值是32
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;
}
（4）HashCode(Map<? extends K, ? extends V>m)——传入对象
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
putMapEntries(Map<? extends K, ? extends V> m, boolean evict):void——传入对象和是否完成初始化，初始化构造map为false
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//s存储键值对的数量
int s = m.size();
if (s > 0) {//键值对大于0
if (table == null) { // pre-size，判断桶table是否初始化
//求出需要的容量，实际长度=容量*0.75，小数相除可能会丢失小数，后面取整可能会使计算的容量小于实际需求的容量，因此需要+1
float ft = ((float)s / loadFactor) + 1.0F;
//判断容量是否超出界限
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//对临界值初始化
if (t > threshold)//threshold为阈值
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
5、增——put(Key, Value):V
public V put(K key, V value) {
/**五个参数，第一个hash值，第四个参数表示如果该key存在值，如果为null的话，则插入新的value，最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可**/
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {//hash函数
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
//hashCode用于返回对应的哈希值
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //指向哈希桶数组的引用top
Node<K,V> p;//指向其中一个哈希桶引用
int n, i;//n代表哈希桶数组的长度，i指代哈希桶数组的下标
//获取长度进行扩容，table一开始并没有加载，而是put之后才开始加载，可能会为null
//判断哈希桶数组是否为空或哈希桶数组长度为0
if ((tab = table) == null || (n = tab.length) == 0)
//扩容后更新数组长度n
n = (tab = resize()).length;
//确定存放位置：如果该哈希桶的位置没有值，就放在该处，若有值，则发生哈希冲突
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//哈希冲突的几种情况
else {
Node<K,V> e; //e临时节点
K k;//存放当前节点的key
//第一种，如果p节点的hash和key分别等于存入key参数指定的hash与key，或者参数key不为空，且参数key的内容等于p点的key，此时p为首节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//令e指向p
//第二种：hash值不等于首节点，为红黑树节点
else if (p instanceof TreeNode)
//在红黑树中添加，如果该节点已存在且不为null，返回该节点，若添加成功返回null
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种是链表节点
else {
//链表需要遍历到最后节点再插入
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {//如果找到尾部，则key没有重复
p.next = newNode(hash, key, value, null);
//判断临界值，如果大于红黑树的阈值就转换红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//链表中有重复的key，e为当前节点，结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//p指向null
}
}
//e==null，则有重复的key，插入新值进行覆盖，返回旧值
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;
}
6、扩容——resize():Node[]
- 主要思考哈希数组长度、临界值、负载因子的关系，与扩容流程
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//将就哈希桶数组用引用保存起来
int oldCap = (oldTab == null) ? 0 : oldTab.length;//保存旧哈希桶数组的长度
int oldThr = threshold;//保存old数组的临界值
int newCap, newThr = 0;//定义新长度和临界值
if (oldCap > 0) {//如果旧哈希桶数组长度大于0，即非首次初始化
if (oldCap >= MAXIMUM_CAPACITY) {//数组长度超过最大值
threshold = Integer.MAX_VALUE;//更新临界值
return oldTab;//返回old数组
}
//非首次初始化的其他情况，长度扩容两倍，扩容后小于最大值大于等于默认值
//##标记
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//将新哈希桶的临界值扩容为原来的两倍
newThr = oldThr << 1; // double threshold
}
//哈希桶数组长度为0，但临界值大于0，说明是已经初始化过，首次初始化临界值为默认值0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//令新数组长度等于old数组临界值
//如果就哈希桶数组容量和数组长度都为0，则首次进行初始化，初始化为默认值
//由此可见在对哈希表进行扩容时，才会对其进行初始化
else {// zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//新数组长度默认初始化
//临界值 = 默认负载因子 * 默认初始容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//##标记的补充，即初始化时容量小于默认值16时，此时的新数组临界值newThr没有赋值，如果新数组的临界值为0
if (newThr == 0) {
//ft为新的临界值
float ft = (float)newCap * loadFactor;
//新数组长度小于最大值且新数组临界值小于最大值，令新数组临界值等于ft，否则赋最大值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;//更新数组临界值
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//初始化，参数为新数组长度
table = newTab;//使table指向newTab
if (oldTab != null) {//如果就数组不为空
for (int j = 0; j < oldCap; ++j) {//遍历oldCap
Node<K,V> e;//临时变量，存储元素
if ((e = oldTab[j]) != null) {//数组下标除有非空值
oldTab[j] = null;//置空
if (e.next == null)//如果该节点没有下一个元素
//将该节点存入newTab中，以哈希值寻址
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//如果e是红黑树
//将此树存入newTab中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order，如果e是链表
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {//遍历链表，转移到newTab中
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;
}
}
}
}
}
//返回扩容后的hashMap
return newTab;
}
7、删除——remove(Object key):V
public V remove(Object key) {
//临时变量
Node<K,V> e;
/**调用removeNode(hash(key), key, null, false, true)进行删除，第三个value为null，表示，把key的节点直接都删除了，不需要用到值，如果设为值，则还需要去进行查找操作**/
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**第一参数为哈希值，第二个为key，第三个value，第四个为是为true的话，则表示删除它key对应的value，不删除key,第四个如果为false，则表示删除后，不移动节点**/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
Node<K,V>[] tab; Node<K,V> p; int n, index;
//哈希数组不为null，且长度大于0，然后获得到要删除key的节点所在是数组下标位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//nodee 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
Node<K,V> node = null, e; K k; V v;
//如果数组下标的节点正好是要删除的节点，把值赋给临时变量node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//也就是要删除的节点，在链表或者红黑树上，先判断是否为红黑树的节点
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
//遍历红黑树，找到该节点并返回
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else { //表示为链表节点，一样的遍历找到该节点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
/**注意，如果进入了链表中的遍历，那么此处的p不再是数组下标的节点，而是要删除结点的上一个结点**/
p = e;
} while ((e = e.next) != null);
}
}
//找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果删除的节点是红黑树结构，则去红黑树中删除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是链表结构，且删除的节点为数组下标节点，也就是头结点，直接让下一个作为头
else if (node == p)
tab[index] = node.next;
else /**为链表结构，删除的节点在链表中，把要删除的下一个结点设为上一个结点的下一个节点**/
p.next = node.next;
//修改计数器
++modCount;
//长度减一
--size;
/**此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理**/
afterNodeRemoval(node);
//返回删除的节点
return node;
}
}
//返回null则表示没有该节点，删除失败
return null;
}
8、获取get(Object):V
public V get(Object key) {
Node<K,V> e;
//也是调用getNode方法来完成的
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
//first 头结点，e 临时变量，n 长度,k 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 &&
((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);
}
}
//找不到，表示不存在该节点
return null;
}
9、修改
元素的修改也是put方法，因为key是唯一的，所以修改元素，是把新值覆盖旧值。
三、总结
（1）HashMap底层维护了Node类型的数组table，默认为null
（2）当创建对象时，负载因子初始化为0.75
（3）在哈希表进行初次扩容resize时，table才进行初始化，table进行初次put时才开始加载
（4）第一次添加put，需要扩容table容量为16，临界值为12
（5）以后再扩容，table容量和临界值扩为原来的两倍
（6）在Java8中，如果一条链表的元素超过TREEIFY_THRESHOLD（8），且table数组的长度大于等于MIN_TREEIFY_CAPACITY（64），会进行树化
