散列是一种用于以常数平均时间执行插入、删除和查找的技术。HashMap是基于哈希表的Map接口实现，该实现提供了所有可选的映射操作，并允许使用 空值和空键。（HashMap 类大致等同于Hashtable，除了它是不同步的并且允许为空值。）这个类不能保证Map的顺序; 特别是，它不能保证顺序会随着时间的推移保持不变。
下面就开始我们的源码分析吧：
老规矩，先贴一张UML图：
①：HashMap直接继承自AbstractMap抽象类，在AbstractMap已经实现了Map接口中的所有方法，只有public abstract Set<Entry<K,V>> entrySet()方法是抽象，由子类实现自己的entrySet（）方法。在HashMap中的一个实例域也和此方法有关联。后面会分析。
②HashMap实现了Map接口，Map中不能使用Map作为key，但Map可以作为value，但是不建议这样做。下图是JDK1.8官方文档给出的解释。
③实现了Cloneable表明HashMap支持可克隆。
④实现了Serializable接口，表明HashMap支持序列化。
好啦，终于到了源码分析的部分了：
下面是HashMap存储结构图：
（该图来自美团技术团队，我分析HashMap的时候，也参考了这里的内容。）
老规矩，我们还是先分析HashMap中的实例域部分（也就是HashMap的属性），但是HashMap比较复杂，它的实例域部分的类型是HashMap中的一个内部类，而对应的内部类又实现了Map接口中声明的一个接口（Map.Entry<K,V>），是不是听起来有点诡异(⊙o⊙)…，为了更好的学习HashMap，我们还是从最外层（也就是Map.Entry<K,V>）开始看起吧。其实很简单的….
1：我们先看看HashMap中的哈希桶（Node<K,V>），它是HashMap中的一个静态内部类，它实现了Map.Entry<K,V>接口，该接口是Map接口内声明的一个内部接口，它表示Map中的一个实体（也就是一个键值对（key-value对））
2：我们先看看Map.EnTRY<K,V>这个接口的源码：
从代码中可以看出，我们可以直接通过该Entry对象获取相应的键和值。它提供了很多有用的方法，代码很简单。不过最后提供了JDK1.8之后新增的方法，主要基于Stream做操作，目前我也仅仅停留在会用阶段，源码分析不来(⊙o⊙)…（后面关于Stream的部分的分析直接跳过(艹皿艹 )）
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
3：我们先看一下HashMap中的第一个字段：transient Node<K,V>[] table，它就是我们的哈系桶数组。接下来给出Node<K,V>的源码。
4：Node<K,V>（哈系桶），它实现了Map.Entry<K,V>接口，下面给出源码：
下面我们逐个介绍一下它的字段的作用：
hash：主要用来定位当前Node在数组位置的索引。
key：键值对中的键。
value：键值对中的值。
Node<K,V> next指代链表中的下一个Node。
部分解释写在 了代码里面。
static class Node<K,V> implements Map.Entry<K,V> {
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;
}
//该方法实现Map.Entry<K,V>接口。
public final K getKey() { return key; }
//该方法实现Map.Entry<K,V>接口。
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//该方法实现Map.Entry<K,V>接口。设置新值，并返回旧值。
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;
}
}5：接着我们看一下HashMap的其他字段：
// HashMap对应的序列化ID。
private static final long serialVersionUID = 362498820763181265L;
//HashMap的哈希桶数组默认的初始化容量（2的4次方（也就是16））
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//HashMap的哈希桶数组的最大容量（2的30次方）
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//HashMap中一个桶的树化的阀值（一旦在同一个哈希桶中的元素超过8个，
//链表就会变成红黑树）
//（这个也是JDK 1.8的新特性）
static final int TREEIFY_THRESHOLD = 8;
/HashMap中一个桶的链表化的阀值（一旦同一个哈希桶中元素少于6个，红黑树就变成了链表）
static final int UNTREEIFY_THRESHOLD = 6;
//哈系桶数组的最小树形化容量
//当哈希桶的容量大于这个值时，表中的桶才能进行树形化
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap中键值对的个数
transient int size;
//HashMap被修改的次数（主要用于快速失败（ArrayList和LinkedList等线程不安全的类都用到了这个变量））
transient int modCount;
//HashMap中实际允许存储的键值对的最大数量
//（一旦超过这个值，表明哈系冲突很严重了，就需要扩容了。）
//threshold = table.length*loadFactor（也就是哈希桶数组的长度*加载因子）
int threshold;
//加载因子(默认值是0.75)
final float loadFactor;
//HashMap中的键值对缓存在entrySet中，即使key在外部修改导致hashCode变化，该缓存中
//仍然可以找到映射关系。
transient Set<Map.Entry<K,V>> entrySet;6：接下来是HashMap的构造函数了：
①默认构造函数：
//默认的构造函数（只实例化了装载因子为0.75）
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
②需要提供两个参数，一个是初始化容量，一个是装载因子。
其中的tableSizeFor(initialCapacity)主要用于找到大于等于initialCapacity的最小的2的幂。
那为么要这么做呢？
首先哈希桶数组的大小必须为2的n次幂，至于为什么必须是2的n次幂，这里暂且不解释，放到在为HashMap第一次添加元素的时候再说，而且此时我们调用该构造方法初始化之后，它并没有初始化哈希桶数组（Node<K,V>[] table），而且此时threshold的值也并不是table.length * Node<K,V>[] table，而是一个大于或等于initialCapacity的最小的2的幂。而且哈系数组也是在我们第一次添加元素的时候初始化的。*
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;
this.threshold = tableSizeFor(initialCapacity);
}
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;
}③只提供一个初始化容量，调用上面的那个构造器，装载因子设置为默认的装载因子。
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}⑤构造函数中需要一个Map作为参数：
其中装载因子使用的默认装载因子0.75。接着调用putMapEntries()方法。
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}当是初始化构造map的时候，evict为false，如果已经初始化完成后，evict为true
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//把map实际存储键值对的大小用一个变量s存储起来。
int s = m.size();
//如果s大于零（键值对的个数大于0）
if (s > 0) {
//如果HashMap中哈系桶数组为空
if (table == null) { // pre-size
//根据m的键值对的数量和HashMap的装载因子计算阀值。
float ft = ((float)s / loadFactor) + 1.0F;
//限制阀值不能超过MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果新阀值t大于HashMap的当前阀值时，则需要重新计算阀值，
//（调用上面我们已经分析过的方法）最后赋值给当前HashMap的阀值。
if (t > threshold)
threshold = tableSizeFor(t);
}
//接着判断如果m的键值对大小大于当前HashMap的threshold，则需要
//调用resize（）方法进行扩容。
else if (s > threshold)
resize();
//最后通过遍历m中的键值对，把键值对添加到我们当前的HashMap中。
//putVal（）方法的具体分析我们后面讲。
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);
}
}
}7：接下来就要看我们的put（）方法（HashMap很多知识点都在这个方法中）
从下面的方法中，我们可以看出，首先需要计算key（键）的哈希值，然后通过哈希值定位当前键值对在我们的哈系桶数组的索引。那我们先看一下这个hash（）方法。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}8：下面是我们计算键的哈系值的方法
先计算键的哈希值，如果键为空的话，则返回哈希值为0，如果不空的话，就把该键hashCode值的高16位与键的低16位做异或运算，把计算后的值返回作为键的哈系值。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}9：下面是putVal（）方法
代码分析如下图所示：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//首先分别定义了一个指向哈希桶数组引用tab，和一个哈希桶引用p，
//n代表哈希桶数组的长度
//i指代哈希桶数组的下标。
Node<K,V>[] tab; Node<K,V> p; int n, i;
//接着判断哈希桶数组是否为空，或者判断哈希桶数组的长度是否为0
if ((tab = table) == null || (n = tab.length) == 0)
//如果条件成立，则需要扩容。（当使用的不是传入map参数的构造器时，第一次添加元素的
//时候，才进行哈系数组的初始化。后面会讲到resize（）方法。）
//最后把扩容后的哈希桶数组的长度赋值给n。
n = (tab = resize()).length;
//接着通过key的哈希值和哈希桶数组的长度减一做与运算，就可以得到该键值对
//对应的哈希桶数组的下标了。其实这里也是为什么会把哈希桶数组的大小设置为2的n次方的
//原因，当哈希桶数组的长度总是2的n次方的时候，(n-1)&hash等价于hash对哈希桶数组
//的长度取模，也就是hash%table.length,但是&比%具有更高的效率。至于为什么等价，
//你可以看看[下面这个链接中的博客，看完你就明白了。](https://blog.csdn.net/aliway89/article/details/43152513)，
//计算好哈希桶数组的索引后，判断一下该索引位置上的元素是否为空，如果
//为空的话，则直接把键值对添加到该位置上。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果计算后的数组的下标对应的位置的元素不为空的话，定义一个新的Node<K,V>,和K。
else {
Node<K,V> e; K k;
//接着判断通过新插入元素的key的哈希值计算得到的哈希桶数组对应下标上的第
//一个元素的哈希值和新插入元素的key的哈希值如果相等，并且对应下标
//的第一个元素键和新插入元素的键相等。则把e=p。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//接着判断p是不是红黑树节点。（当同一个哈希桶中元素超过8个，就会
//变成红黑树节点。）
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果不是红黑树节点，则依次遍历链表中的节点，直到找到链表中某个节点
//的下一个节点为空，则把对应的键值对填充进去，接着判断链表的节点数
//是否超过8，如果超过8的话，链表就会转化为红黑树。
//最后跳出for循环。
//或者是当前键和哈希桶中的键的哈系值相等并且键的值也相等，则跳出循环。
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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;
}
}
//如果key已经存在了，则把键对应的值替换掉，返回旧值。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//允许LinkedHashMap后动作的回调
afterNodeAccess(e);
return oldValue;
}
}
//最后把modCount++（用于快速失败）
++modCount;
//如果HashMap中键值对的个数大于HashMap允许的最大容量时，则进行扩容。
if (++size > threshold)
resize();
//允许LinkedHashMap后动作的回调
afterNodeInsertion(evict);
return null;
}10：扩容方法：
final Node<K,V>[] resize() {
//首先把旧的哈希桶数组用一个引用保存起来。
Node<K,V>[] oldTab = table;
//把旧哈希桶数组的长度也保存起来。
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//把旧哈希桶数组允许的最大键值对数也保存起来。
int oldThr = threshold;
//定义新的长度和容量。
int newCap, newThr = 0;
//在旧的哈希桶数组的长度大于0的情况下进行判断。
if (oldCap > 0) {
//如果就的哈希桶数组的长度大于等于所允许的最大哈希桶数组的长度时
if (oldCap >= MAXIMUM_CAPACITY) {
//则把最大哈希桶数组的长度给HashMap中所允许的最大键值对的个数。
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则判断新的哈希桶数组的长度是旧的哈希桶数组长度的两倍且必须
//小于最大容量。而且得满足旧的容量大于默认的初始化容量。
//把允许的最大键值对数扩容为原来的两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 如果旧的允许的最大键值对数大于0，则新的容量等于旧的允许的最大键值对数。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//否则的话，则把心的哈希桶数组的长度和允许的最大键值对数设置为默认值。
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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;
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 { // preserve order
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;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}总结：
①对于HashMap底层实现的学习，建议还是通过debug的方式，这样通过IDE辅助的方式，能够更好地理解HashMap的底层实现。
②下面我们给出一个例子，当同一个哈希桶中的元素超过8个的时候，链表就会变成红黑树。
因为整型的数字的哈希值等于本身，下面依次添加的元素计算的数组索引都是1，索引当同一个哈希桶中元素超过8后，相应的链表就会变成红黑树，你可以打个断点debug一下。
HashMap<Integer,Integer> hashMap = new HashMap<>();
hashMap.put(1,1);
hashMap.put(17,2);
hashMap.put(33,3);
hashMap.put(49,4);
hashMap.put(65,5);
hashMap.put(81,6);
hashMap.put(113,7);
hashMap.put(129,8);
// 当冲突超过8后，会变成红黑树
hashMap.put(145,9);