预热
分析任何源码之前都要先用一遍，HashMap也不例外。
import java.util.HashMap;
public class Demo {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "Cracker13");
System.out.println(hashMap.get(1));
}
}
这个段简单的代码，实现了HashMap存、取两个操作。HashMap的结构特点是以键值对的形式。
接下来我们就开始分析源码。
猜想
在分析源码之前，我们根据已有的知识猜想下HashMap可能的数据结构。
(1)数据结构
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
引入：我们可以看到这里有五个参数，第一个参数对key的值进行了一次计算，第二个参数就是key，第三个参数value，后面2个先不管。
猜想：这里的hash(key)是不是在进行一个下标位置的计算？
思考：key, value进行存储的话，使用的数据结构是什么？HashMap使用的数据结构？
这里我们想到常用的数据结构为ArrayList和LinkedList，即数组和链表
ArrayList底层实现为数组，查询效率比较快(get)
ArrayList的数据结构：
LinkedList底层实现为双向链表，增加和删除比较快(add，delete)
LinkedList的数据结构:
猜想：HashMap能不能引入一个查询效率快，且增加和删除元素效率高的数据结构？
能不能结合ArrayList和LinkedList的优势，所以我们能推出HashMap源码底层的数据结构可能是采用的是数组+链表的形式。
结论：HashMap数据结构(存储键值对)
（2）节点的数据结构
猜想：那么接下来我们就来猜一猜HashMap中到底有些什么东西
推测HashMap中存储的基本单元
思考：HashMap源码中key，value的存储单元是什么？
Java是一门面向对象的语言，能不能用一个对象(Node)来存储key，value？
class Node {
private Object key;
private Object value;
}
因为HashMap数据结构为数组+链表，所以Node中应该有一个指针指向下一个节点
class Node {
private Object key;
private Object value;
private Node next; //用来指向链表的下一个节点
}
因为key和value的类型为已知的，可以传进HashMap，所以key和value前定义为Object不合适，应该用泛型(K，V)来表示key，value的类型
class Node<K，V> {
private K key;
private V value;
private Node<K，V> next;
}
HashMap源码中Node的表示：
结论：猜测Node表示和源码表示结果出入不大
（3）数组的数据结构
猜想：数组这种数据结构在HashMap中该怎么表示？
平常基本类型用Int，String等类型表示。数组用Int[]，String[]来表示，那么在HashMap中应该有一个来表示Node<K，V>[] table来表示数组
HashMap源码中表示Node数组：transient代表不可序列化
结论：HashMap中确实有一个Node<K，V>[] table来表示数组
（4）数组的初始大小
猜想：数组要不要有一个大小呢？
初始大小和上限大小？
猜测HashMap中可能有与default_size和max_size类似变量来表示数组的初始大小和上限大小
HashMap源码：DEFAULT_INITIAL_CAPACITY表示默认容量，MAXIMUM_CAPACITY表示最大容量
大小的一个解决方案
假如初始大小为16，如果数组的大小不够用了，或者达到某个值了，是不是应该进行数组扩容呢？
猜想：HashMap中应该有一个扩容的resize方法
HashMap源码：
(5)扩容是不是应该有一个依据？是在数组使用完才扩容还是当数组使用到达一个阈值的时候就扩容？
猜想：扩容时依据数组已经使用容量大于阈值时扩容，如果是大于数组的长度才扩容，这显然是不理想的，效率很慢(这里的阈值小于数组的长度)。
比如数组长度为16，那么数组大小已经达到12的时候就应该扩容，而不是等数组长度达到16时才扩容。
此时应该有一个size来表示数组的使用大小，还有一个小于1的数来乘以数组长度得到数组扩容时的阈值。
HashMap源码：
默认负载因子<1(DEFAULT_LOAD_FACTOR表示默认的负载因子)
数组已使用大小size
size++判断是否到达扩容的阈值，threshold = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR
(6)链表长度过长效率会下降，HashMap是否也应该有一个阈值来控制链表的长度？大于阈值时是不是该将链表转换为其他数据结构呢？
猜想：HashMap应该有一个阈值来控制链表的长度，当链表长度大于阈值时将链表转换为二叉树或者B 树等数据结构，提高效率。JDK1.8中HashMap采用的是链表转转红黑树，因为红黑树相比于二叉树在失衡的时候旋转的时间复杂度为O(1)
HashMap源码：用TREEIFY_THRESHOLD来控制链表的长度
链表转红黑树:使用treeifyBin方法来将链表转换为红黑树
(7)新来的Node节点到底存在哪里?
猜想：存哪里应该有一个约束，这个约束应该是经过我们计算得来的(现在只知道key和value)，那么我们可以用key进行一个计算，计算出这个Node到底存在哪里。那么计算的函数呢？是使用Md5(key)还是Base64？Java中万物皆对象，所有类都是Object的子类，我们可以利用hashcode()方法计算返回一个int值，key.hashcode()就知道存在数组的哪个位置了。但是key.hashcode算出来的int值容易越界，所以应该经过hash函数得到我们的理想值(key.hashcode()%length)得到小于数组的int值
HashMap源码:
static int indexFor(int h, int length) {
return h & (length - 1); //JDK1.8中没有此方法，但实现原理一样，通过位与运算达到取模的作用
}
源码分析
（1）构造方法
上面的例子中用了new HashMap<>()这个方法
HashMap还有几个构造方法：
- HashMap(int initialCapacity, float loadFactor)
- HashMap(int initialCapacity)
- HashMap(Map<? extends K, ? extends V> m)
（2）put()方法、putVal()方法
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) {
HashMap.Node<K, V>[] tab;
HashMap.Node<K, V> p;
int n, i;
// 首先判断table是否包含数据，没有数据则要进行第一次扩容
if ((tab = table) == null || (n = tab.length) == 0)
// 调用resize()方法进行初始化
n = (tab = resize()).length;
// 对hash码进行取模运算获取key所在的位置，若p == null 表示为新元素
if ((p = tab[i = (n - 1) & hash]) == null)
// 将新元素插入到数组的第i个位置
tab[i] = newNode(hash, key, value, null);
// 不是新元素
else {
HashMap.Node<K, V> e;
K k;
// 通过equals()方法判断元素是否存在，若存在则替换
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如判断此时是否为树结构
else if (p instanceof TreeNode)
e = ((HashMap.TreeNode<K, V>) 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);
// 如果此时链表长度大于等于8 将链表转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 修改记录次数
++modCount;
// 如果超过临界值 再进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
（3）hash()方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
因为我们要知道key,value这个对象到底存在hashMap的哪里。
充分的将int类型的32位数全部应用起来，该数的高16位与低16位做一个^抑或运算，得到的一个二进制的值就知道key,value这个对象存到哪了。
但是你怎么知道它不会越界呢？
再去putval()方法中
如果(tab=table==null)的话，就执行resize()方法，对我们的数组进行初始化大小，n就是默认数组的大小。
n的默认大小是16也就是10000
那n-1就是 01111 与hash值去进行与运算，就可以确保这个数组大小最大也只能是15，所以不会越界
数组的散列性就大了，碰撞概率就低了
数组大小一定要是2的N次幂
如果这个地方没有值，那就将该对象存储到这里
如果这个地方有值，那就用链表的方式往下存储，红黑树扩展。
（4）扩容
-
第一次使用，会分配一个初始大小
如指定6则转化为8，指定11则转化为16。
原理
-
扩容的触发条件
扩容的触发条件通过一个叫(threshold)阈值的参数控制的,阈值的计算公式是数组长度threshold(阈值)=capacity(容量)*loafFactor(负债因子)。
以后往HashMap填充的数据如果到达一定量，就把旧数组扩大一倍。 -
扩容机制
final Node<K,V>[] resize() {
//获取旧数组的引用
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//当健值容量已经达到最大
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
//直接返回数组最大值
return oldTab;
}
//没有超过最大值，扩充为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0)
//初始化容量赋值阀值
newCap = oldThr;
else {
// 初始化默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//新的阀值==0重新resize
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//把每个桶里的数据转移到新的桶里
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//给e赋值
if ((e = oldTab[j]) != null) {
//清除老数组的索引
oldTab[j] = null;
if (e.next == null)
//重新生成下标并把数据放入对应下标数组里
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//给红黑树赋值
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 链表大于8小于1
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> 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;
}
//原索引+oldcap放到桶里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。
e.hash & oldCap这行代码跟扩容、链表重排列有关系
（5）哈希冲突解决方案
HashMap采用的是链地址法，jdk1.8之后还增加了红黑树的优化
- 当链表的长度>=8且数组长度>=64时，会把链表转化成红黑树。
- 当链表长度>=8，但数组长度<64时，会优先进行扩容，而不是转化成红黑树。
- 当红黑树节点数<=6，自动转化成链表。
（6）查找元素
final HashMap.Node<K, V> getNode(int hash, Object key) {
HashMap.Node<K, V>[] tab;
HashMap.Node<K, V> first, e;
int n;
K k;
// 将原数组中的数据赋值给tab 并判断tab数组的长度是否大于0 并且看能否在数组中获取key所在的位置且不为null 校验未通过返回Null
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
// 判断是否是hash冲突的元素
if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果出现hash冲突会将元素添加到链表中，如果next！=null表示为链表结构 需要从链表中获取
if ((e = first.next) != null) {
// 当链表的长度达到8时 将链表转换为；此时判断是否是红黑树，并从其中获取数据
if (first instanceof TreeNode)
return ((HashMap.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;
}
（7）非默认序列化
HashMap 并没有使用默认的序列化机制，table变量被transient修饰，无法序列化，而是通过实现readObject/writeObject两个方法自定义了序列化的内容，因为序列化 talbe 存在着两个问题：
-
table 多数情况下是无法被存满的，序列化未使用的部分，浪费空间
-
同一个键值对在不同 JVM 下，所处的桶位置可能是不同的，在不同的 JVM 下反序列化 table 可能会发生错误