1. 初始化，hashMap初始化容量默认大小为16，默认负载因子为0.75F
一共有3个构造器
- 无参
- 带初始化容量
- 带初始化容量和初始化加载因子
前两个构造器都是调用第三个构造器。如果没有设置初始化容量或负载因子，以默认值创建。值得一提的是：
-
在调用构造器创建HashMap时不会立即创建容器，（在jdk1.8之后为 Node<K,V>[] table 用于存储键值对）。而是会在你第一次put元素的时候调用resize方法创建。
-
容器的大小必须为2的倍数。你在设置初始化容器大小时，如果输入的不是2的倍数，那会自动调整为最接近的大于输入值的2的倍数。主要在tableSizeFor这个方法实现。
该方法，先获取 输入数-1 的32位二进制前导零数目(这里-1理解一下就好了，不-1那对于恰好是2的倍数的，会扩大一倍)。-1无符号右移前导零数目位，这样就得到了最接近 输入数 的 2的倍数-1。最后判断n的大小，
如果n=-1表示cap=1，那就设置容量为1；
如果n>0,如果大于最大容量，那就设置为最大容量，否则设置为n+1。 -
hashMap有最大容量。2^30
-
链表长度阈值
当长度大于8时，会从链表转化为红黑树。至于为什么设置为8主要是理想状态下，设置合理的HashMap，根据泊松分布计算得到链表长度达到8的概率极低( 0.00000006),故而设置为8可以减少链表转化为红黑树的可能性。毕竟红黑树创建修改太耗时了。
2. put方法
该方法其实调用了putVal方法。这里需要注意的是hash方法
static final int hash(Object key) {
int h;
//这里存在key为null的判断，故而hashmap支持key为null，这里hashcode要这样计算就是为了打乱hashcode，根据注释所讲，主要是因为输入分布可能导致hashcode相似。故而用这种方法打乱。
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
思路为
1. 判断容器数组是否为空，为空则创建数组
2. 判断插入元素对应的数组位置
1. 数组对应位置为空，直接插入
2. 数组对应位置为红黑树，如果没有该键值对，红黑树直接插入。有的话，把该键值对引用保存下来。
3. 数组对应位置为链表，如果没有该键值对，先插入再判断链表长度是否大于8，大于则进行红黑树的转换，如果有的话，把该键值对保存下来
3. 如果容器中原来有该键值对，替换该键值对的值
4. 判断容器中键值对数目是否大于边界值，如果是，扩容
**/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果容器为空或者长度为0，调用resize方法创建容器，n为当前容器数组长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(n - 1) & hash相当于取余运算，这里表示，如果插入元素的键在数组上的映射位置为null，直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果数组上第一个元素就发生hash冲突，如果键的值(equals方法)相等那表示相同元素，覆盖
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//否则，如果当前元素为红黑树，那插入红黑树
e = ((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);
//如果达到阈值，那就会将链表转换为红黑树，这里显示当链表长度大于阈值就会转化，其实你进入treeifyBin会发现还有个条件，如果当前数组长度小于MIN_TREEIFY_CAPACITY(64)时，它会扩容，而不会转化为红黑树
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;
}
}
//e不为null表示已存在该元素
if (e != null) {
V oldValue = e.value;
//如果是调用put方法插入数据，这里onlyIfAbsent为false，所以一定会覆盖值的，如果调用putIfAbsent方法插入值，会保留原来值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//该方法在hashMap中是一个空函数，在LinkedHashMap返回下一个节点
afterNodeAccess(e);
//返回原来值
return oldValue;
}
}
//这是个类成员变量，记录hashmap被结构化修改的次数
++modCount;
//如果容器内键值对的数目大于阈值，将扩容
if (++size > threshold)
resize();
//afterNodeAccess差不多
afterNodeInsertion(evict);
return null;
}
3. resize方法
扩容必定涉及到原来位置的元素在新数组的存放位置，我们需要理解jdk1.8之后hashmap rehash的方法，观察下图
该图来自黑马教程
因为每次扩容只会变成原来的两倍，所以，rehash后新元素的下标等于原来元素的下标或者原来元素下标+2^n，这取决于第n位的元素是不是1(1.8之前采用的不是这种方法，而是直接重hash+头插，会有死循环的bug).理解了这个再看源码
/**
思路为
1. 获取新数组的大小和边界值，生成新容器数组
2. 判断是否为第一次创建
3. 如果是，直接返回新的容器数组
4. 如果不是，进行旧数组到新数组的拷贝和重hash
**/
final Node<K,V>[] resize() {
//获取到当前的数组容器
Node<K,V>[] oldTab = table;
//获取数组长度，如果为null，长度设为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//获取边界值，如果你构造方法里有设置初始化大小的话，看上面初始化哪里，你会发现，这时候的threshold其实等于数组长度而不是边界值。
int oldThr = threshold;
int newCap, newThr = 0;
//如果原来容器数组存在
if (oldCap > 0) {
//如果大于等于最大容量，那无法扩容了，直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果旧数组的长度两倍小于最大容量，大于默认初始化容量，那么边界值扩大两倍，数组长度扩大两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0)
//如果原来容器不存在，但是oldThr大于0，表示手动设置了初始化容器，上面直到此时的oldThr其实表示的是容器大小，所以设置新容器大小为oldThr
newCap = oldThr;
else {
//如果原来容器不存在且没有手动设置大小，那么直接用默认值
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)
//再hash
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//这个方法对红黑树进行重hash，值得一提的是，当红黑树节点小于等于6时，会将红黑树转化为链表
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//对于原来数组中同一条链表上的元素，rehash后要么位于相同下标的链表，要么位于当前下标+2^n的位置的链表，loHead,hiHead分别为表头
do {
next = e.next;
//如果第n位元素为1，那放到loHead链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//如果第n位元素为0，那放到hiTail 链表
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;
}
4. 链表转红黑树
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//当数组为空或数组长度小于64时，会扩容，不会转化红黑树
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
//将链表上的节点转化为树节点，一个个串起来
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//将树根节点放到数组中相应位置，并整理生成红黑树
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
5. remove方法
该方法调用了removeNode方法
/**
思路为
5. 先匹配到要删除的节点
6. 判断节点类型
7. 删除节点，如果时红黑树还可能会进行红黑树转化为链表
**/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//如果容器数组不为空，长度大于0，且该值存在
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//如果第一个元素就是该元素，将该元素赋值给node，否则通过链表/红黑树遍历寻找到该元素，赋值给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);
}
}
//如果查找到匹配的node元素，删除该元素，在remove方法中后面的判断条件一定为true
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
//删除红黑树节点，当树的节点数小于6会将树转化为链表
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
总结：
- hashMap什么时候会扩容
- 第一次put数据
- 当数组长度大于边界值
- 当数组中链表长度大于8但是数组长度小于64时
- 为什么每次都以2的倍数扩容
我们可以发现当容器为2的倍数时，许多运算都可以用位运算替代，速度十分快。同时我们通过上面1.8之后的rehash方法发现，容器每次以2的倍数扩容，对于rehash是十分方便的，另外以2的幂次作为长度，可以使hashcode分布均匀，减少hash冲突。 - 为什么hashmap线程不安全
个人理解
整个hashmap源码中都没有对于多线程进行同步资源访问的限制，当然不安全。漏洞很多。包括put时，对于容器数组同一个位置插入时，两个线程同时竞争访问。当resize时，线程时间片执行完毕，另一个线程又有插入操作，还有关键是table和size是线程不可见的。网络上主要两个观点，1. 两个线程同时插入会导致后一个覆盖前一个。2. 1.8之前resize导致死循环，我感觉都有点问题。先不说rezsize死循环是代码bug导致的,1.8修复之后不会出现死循环了，单仍然线程不安全。关键是table是线程不可见的。那些例子在没有刷回内存时，是不成立的。那些例子只是table没有设置同步资源访问和线程可见性下的特殊情况罢了。。。 - hashMap和hashTable，ConcurrentHashMap的线程安全比较
- hashMap线程不安全，hashTable通过synchronized实现线程安全
- ConcurrentHashMap(1.8之后?我没看过1.8之前的源码)通过synchronized+cas实现线程安全。
- hashTable其实是对增加删除方法添加了synchronized关键字。而ConcurrentHashMap比较复杂，总体上其实是对容器中插入删除操作的单个节点使用cas或synchronized，对于resize操作通过一个全局的状态量锁住。
- hashMap容器数组remove元素并不会导致数组变小。数组只会通过put不断变大，不会通过remove变小
来源：CSDN
作者：yahahassr
链接：https://blog.csdn.net/yahahassr/article/details/104757737