1. 初次看源码的童鞋，需要静下心来一步步走，多尝试几次就可以，一定要稳住。
2. 先理解什么是HashMap
在JDK1.7和之前，HashMap使用的数据结构是数组+ 链表，JDK1.7之后，使用的数据结构是数组+ 链表/红黑树，红黑树的插入，查找，删除等操作，平均复杂度均为O(logn)。
哈希表添加，删除，查找等操作，性能十分之高，不考虑哈希冲突，时间复杂度为O(1)即可完成。一般是我们key，通过hash函数f进行映射，取余后得到数组下标（有时候也叫做桶下标）进行插入，如：key --> f (key) % n --> index。当遇到hash冲突的时候，一般解决方法是线性探针法和拉链法（也称链地址法），HashMap中hash冲突使用拉链法。
结构图如图所示 ： 传送门
2.源码分析，戳进HashMap类中。源码先从构造搞起
2.1 在分析构造函数前，先看看定义的几个关键变量
// 默认容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量为2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
// 有人会问为什么不设置成1<<31？因为有符号整形表示的范围为-2^31~2^31-1,因此溢出为最小负值。
//那为什么是不是(1<<31)-1?因为hash运算过程中要求扩容大小为2的n次幂，从而减小哈希碰撞，-1不满足幂次运算
// 也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 桶上链接的节点数大于等于8链表转成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 桶上链接的节点数小于等于6退化成链表
static final int UNTREEIFY_THRESHOLD = 6;
// 最小的红黑树容量，允许存在64个节点，大于则调整
static final int MIN_TREEIFY_CAPACITY = 64;
// 定义装填因子
final float loadFactor;
// 为capacity*loadFactory，此时大于threshold则进行扩容
int threshold;
2.2 4种构造方法
- 无参构造方法
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
- 有容量参数的构造方法
public HashMap(int initialCapacity) {
// 其实调用了HashMap(int initialCapacity, float loadFactor)
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- 带容量参数和装填因子的构造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 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;
// 调用tableSizeFor,运算过程如下
this.threshold = tableSizeFor(initialCapacity);
}
其中调用了tableSizeFor()方法，返回一个值大于cap且最接近cap的2正数的幂次。
static final int tableSizeFor(int cap) {
// 防止当前容量已经满足2的幂次
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;
}
这段代码移位操作比较麻烦，我自己debug并参考了其他人文章才理解，建议手动模拟操作一下就十分好理解。为什么这么操作，参考一篇博客：传送门
第一次右移
n |= n >>> 1;
由于n不等于0，则n的二进制表示中总会有一bit为1，这时考虑最高位的1。通过无符号右移1位，则将最高位的1右移了1位，再做或操作，使得n的二进制表示中与最高位的1紧邻的右边一位也为1，如0000 1xxx xxxx xxxx
第二次右移
n |= n >>> 2;
注意，这个n已经经过了n |= n >>> 1; 操作。假设此时n为0000 11xx xxxx xxxx，则n无符号右移两位，会将最高位两个连续的1右移两位，然后再与原来的n做或操作，这样n的二进制表示的高位中会有4个连续的1。如0000 1111 xxxx xxxx
第三次右移
n |= n >>> 4;
这次把已经有的高位中的连续的4个1，右移4位，再做或操作，这样n的二进制表示的高位中会有8个连续的1。如0000 1111 1111 xxxx
最后
n |= n >>> 16; ，最多也就32个1，可以保证最高位后面的全部置为1，但是这时已经大于了MAXIMUM_CAPACITY ，所以取值到MAXIMUM_CAPACITY 。
————————————————
- 调用参数为map类型的构造方法，其实做的就是一个新的深拷贝（debug就可以看到，变动原map，新的构造方法map值不变）
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 构造一个和指定Map有相同类型的HashMap,其实就是参数的深拷贝
putMapEntries(m, false);
}
其中调用了putMapEntries()方法，源码如下
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
// 传入的参数m的大小
int s = m.size();
if (s > 0) {
// 如果table没有被初始化
if (table == null) { // pre-size
// 初始化新的HashMap容量
float ft = ((float)s / loadFactor) + 1.0F;
// t表示真正需要的容量
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 得到要创建的初始容量，为2的幂次个，存入threshold
if (t > threshold)
threshold = tableSizeFor(t);
}
// 当初始化过后，则重新调整容量大小
else if (s > threshold)
resize();
// 遍历map中的元素
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
// 调用函数，将hash值key，key，value存入到桶中
putVal(hash(key), key, value, false, evict);
}
}
}
其中调用了resize()方法和putVal()方法和hash()方法，源码如下：
扫描二维码关注公众号，回复：
10714512 查看本文章
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// tab为放节点的桶，p为节点，他们只是被封装成了Node结构
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果桶是新桶没有内容或者桶长度为空，则调用resize得到需要的槽，resize操作如下---
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// （n -1） & hash表示得到key经过hash映射后的索引，p = tab[i]表示指向key要放的位置
// 当p为空即第一次放时候，调用newNode创建一个头节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果要放的位置已经有元素了，分两种情况
// 1. key值相同，则替换val
// 2. key值不同，则存于链表中或者红黑树中
else {
Node<K,V> e; K k;
// 情况1，如果要放的key的hash值相等（冲突）且 （key相同或（key不为空且equal判等））
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 则p指向该节点
e = p;
// 情况2，如果现在p节点为红黑树结构，则放入到红黑树中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 否则放入到链表中
else {
// 遍历链表
for (int binCount = 0; ; ++binCount) {
// 如果遍历到最后一个节点，即没有找到key值相同的，则生成一个新节点
if ((e = p.next) == null) {
// 生成新节点，放到链表的尾部
p.next = newNode(hash, key, value, null);
// 放完后进行判断，是否需要升级成红黑树，大于8则转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果遍历中途发现key的hash值映射相同，且要放置的key与映射位置的key相同或（key不为空且equal判等）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 则p指向该节点
p = e;
}
}
// 如果映射的key指针e不为空，则进行替换值
if (e != null) { // existing mapping for key
// 将旧值保存
V oldValue = e.value;
// 用新值替换旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//
afterNodeAccess(e);
return oldValue;
}
}
// modeCount用来记录是否变化，hashmap使用fast-fail迭代机制，如果在迭代过程中发现modecount是否为exceptedmodecount，如果不是则返回异常
++modCount;
// 如果容量大于门限，则调整容量
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
hash()方法源码如下:
static final int hash(Object key) {
int h;
// hashCode()调用的是顶层Object类的native函数 "public native int hashCode();"，目的是为了得到key的hashCode值
// hashmap允许放key为null的值，当为null，则表示位于桶0号位置，为什么会用异或一个无符号右移的16位置自己？
// 这样做的目的是为了让hash更随机，高位右移与高位异或，高位保留了信息，低位也保留了高位的信息，随机性大
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
resize()方法源码如下:
final Node<K,V>[] resize() {
// oldTab保存旧的table
Node<K,V>[] oldTab = table;
// 得到旧的oldTab的容量，门限值
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
// 新的table容量，门限值
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
}
// 如果之前的oldCap <= 0,表示新创建的HashMap，如果oldThr > 0，表示调用HashMap构造函数HashMap(int initialCapacity)成功并初始化了
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 如果之前的oldCap<= 0 且oldThr < 0 表示调用HashMap空参构造函数HashMap()成功
else { // zero initial threshold signifies using defaults
// 使用默认值初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 如果新的门限值为0，对于新创建的HashMap需要计算它的应该门限值
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"})
// 初始化table
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;
// 如果后面还有，且为红黑树节点，则进行红黑树的重新hash映射找位置放
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 如果后面还有，且为链表节点，则重新hash映射后链起来
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;
// 如果当前桶指向的元素与旧元素hash值相同，说明重新hash后位置不变
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()结构图如下：传送门
3. 大体流程结构图(参考原文：传送门)
4. 总结
比较新手，也参考了一些文章。建议看源码不舒服的，使用debug一步步走下去，然后看着注释理解就ok，不懂就参考几个一起看，理解就会更深刻。看加整理耗费了好几天，如果有疏漏，恳请指正。
