本文章包含个人理解与参考文章部分内容，参考文章链接如下，侵权请联系我删除，谢谢
参考文章
其次，由于自始至终搞不定这玩意的排版，所以排版很有问题，分享有道云笔记的内容
有道云链接地址
CSDN链接地址
欢迎留言进行讨论
HashMap在JDK1.8结构上为数组+链表+红黑树；JDK1.8之前都为数组+链表结构；
因此，HashMap中数组table中某Node形成的链表长度超过TREEIFY_THRESHOLD（8） 时，会将其转换为红黑树，同理当红黑树小于UNTREEIFY_THRESHOLD（6）时，红黑树会转换为链表。
扩容：HashMap底层数组默认初始容量为16，负载因子为0.75，也就是说当数量达到16*0.75=12时就会将当前16的容量进行扩容。扩容需要进行reHash、复制数据等操作（及其消耗性能）。
参数
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable {
//序列号，序列化的时候使用。
private static final long serialVersionUID = 362498820763181265L;
/**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。**/
// 2的n次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，2的30次方。
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;
//当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
static final int MIN_TREEIFY_CAPACITY = 64;
-----------------------上方为常量--------------------------
-----------------------下方为变量--------------------------
//transient关键字表示该属性不能被序列化
////节点表(数组的每一个位置上存储一个节点表)
transient Node[] table;
//将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set> entrySet;
//元素数量
transient int size;
//统计该map修改的次数
transient int modCount;
//临界值，也就是元素数量达到临界值时，会进行扩容。(=capacity*loadFactor)
int threshold;
//也是负载因子，
final float loadFactor;
HashMap初始化数组大小为DEFAULT_INITIAL_CAPACITY （2的n次幂 16）16时统计结果的最优解，TREEIFY_THRESHOLD ，UNTREEIFY_THRESHOLD 也是如此
结点内部类
static class Node implements Map.Entry {
// 当前key的hashcode
final int hash;
final K key;
V value;
// next指向下一个节点
Node next;
Node(int hash, K key, V value, Node next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
结点内部类，是一个单向链表，组成 数组Node
存储键值对时，实际上是存储在一个Entry对象中，通过key计算出Entry对象的存储位置。Key -->Value的对应关系，通过key-->Entry--->value实现
红黑树结构
static final class TreeNode extends LinkedHashMap.Entry {
TreeNode parent;
TreeNode left;
TreeNode right;
TreeNode prev;
boolean red;
TreeNode(int hash, K key, V val, Node next) {
super(hash, key, val, next);
}
}
构造函数
（1）hash（key）
（2）初始化数组大小
（3）根据hash&（n-1）得到位置，进行存储
（4）存储方式：
- 值的覆盖；
- 链表
- 红黑树
（5）数组大小超过阈值进行扩容
/**
* 用指定的初始值构造一个空的HashMap
* capacity（容量） and load factor（负载因子）.
*@throws 当初始容量（initialCapacity）为负数或者负载因子（loadFactor）是非正的，报出IllegalArgumentException
*/
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;
////调用tableSizeFor方法,因为HashMap的容量必须为2的幂次方，例：15----2^4
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 用指定的初始值构造一个空的HashMap
*默认负载因子为(0.75) 需指定初始容量
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 默认初始容量为16，负载因子为0.75
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//创建一个内容为参数m的内容的哈希表
//采用默认的加载因子
public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
this.putMapEntries(m, false);
}
-----------------------上方为四种构造函数--------------------------
-----------------------下方为构造函数使用的方法--------------------------
// 返回大于输入参数且最近的2的整数次幂的数
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;
}
// 将整个集合中的数据放到HashMap中保存
final void putMapEntries(Map m, boolean evict) {
int s = m.size();
if (s > 0) {
//数组还是空，初始化参数
if (table == null) {
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
//数组不为空，超过阈值就扩容
else if (s > threshold)
resize();
for (Map.Entry e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//先经过 hash() 计算位置，然后复制指定 map 的内容
putVal(hash(key), key, value, false, evict);
}
}
}
添加元素
put方法
- 高十六位不变，低十六位与高十六位进行异或，
- hash&（n-1）---->得到下标
- 对Key求hash值，然后计算下标。
- 如果没有碰撞，直接放入桶中。
- 如果碰撞了，以链表的方式连接到后面。
- 如果链表长度超过阀值（TREEIFY_THRESHOLD(=8)），则链表转换为红黑树。
- 如果节点已经存在，则替换旧址，并return旧值。
- 如果桶满了（容量*负载因子），则需要进行resize（扩容）。
//添加指定的键值对到 Map 中，如果已经存在，就替换,并且返回oldvalue
public V put(K key, V value) {
//调用 hash() 计算位置
//调用putVal()方法进行保存key-value
return putVal(hash(key), key, value, false, true);
}
// hash 将hashCode带符号右移16为 前面补0
//在于原值进行异或运算
//相当于将二进制的hashcode为32为 分为高十六位和低十六位
//高十六位与低十六位进行异或运算，以此降低碰撞概率
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
putVal()
存值： p = tab[i = (n - 1) & hash]
这时，n等于默认值16，n-1=15，二进制为01111
拿hash与n进行异或运算得到存储位置（为了得到一个十六以内的数）
如果n=15，n-1=14； 那么二进制为01110，这时无论原本hash的最后一位为0还是1 与n异或后都是0 这将大大的提高了碰撞的概率，这也是为什么容量一定要为2的n次幂的原因
至于为什么都采用异或运算 请看文章尾部注解
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//当数组table为null时, 调用resize初始化数组table, 并令tab指向数组table，n=默认大小16
if ((p = tab[i = (n - 1) & hash]) == null) //如果新存放的hash值没有冲突
tab[i] = newNode(hash, key, value, null);
//则只需要生成新的Node节点并存放到table数组中即可
else { //否则就是产生了hash冲突，三个解决方式（1）value覆盖（2）链式存储（3）红黑树方式存储
Node e; K k;
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p; //如果hash值相等且key值相等, 则令e指向冲突的头节点
else if (p instanceof TreeNode)
//如果头节点的key值与新插入的key值不等, 并且头结点是TreeNode类型,说明该hash值冲突是采用红黑树进行处理.
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
//向红黑树中插入新的Node节点
else { //否则就是采用链表处理hash值冲突
// JDK1.7是头插法，整个链表向下移动，多线程进行操作时，容易死循环
// JDK1.8是尾插法
for (int binCount = 0; ; ++binCount) {
//遍历冲突链表, binCount记录hash值冲突链表中节点个数
if ((e = p.next) == null) { //当遍历到冲突链表的尾部时
p.next = newNode(hash, key, value, null); //生成新节点添加到链表末尾
if (binCount >= TREEIFY_THRESHOLD - 1)
//如果binCount即冲突节点的个数大于等于 (TREEIFY_THRESHOLD(=8) - 1),
//便将冲突链表改为红黑树结构, 对冲突进行管理, 否则不需要改为红黑树结构
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) //如果在冲突链表中找到相同key值的节点, 则直接用新的value覆盖原来的value值即可
break;
p = e;
}
}
if (e != null) { // 说明原来已经存在相同key的键值对
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//onlyIfAbsent为true表示仅当不存在时进行插入, 为false表示强制覆盖;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //修改次数自增
if (++size > threshold) //当键值对数量size达到临界值threhold后, 需要进行扩容操作.
resize();
afterNodeInsertion(evict);
return null;
}
扩容：resize()
threshold=DEFAULT_INITIAL_CAPACITY （默认容量）DEFAULT_LOAD_FACTOR（负载因子） =160.75=12
容量： newCap = oldCap << 1 右移1 即乘以2
阈值： newThr = oldThr << 1
新建数组后需要重新将原本的键值对进行迁移；
if ((e.hash & oldCap) == 0) 16的二进制为10000
e.hash 到数第五位为0，那么最终结构为0---->链表还是原来的位置村粗
e.hash 倒数第五位为1，那么最终结果为1---->链表就是原本的的位置加+oldCap（16）----> 例如原本是1 现在是1+16=17
扩容操作，将容量扩充为原本的两倍，然后对每一个节点重新计算hash值，这个值只可能在两个位置，一个是原下标的位置，另一种是在下标为<原下标+原容量>的位置
final Node[] resize() {
//保存当前的节点集合数据
Node[] oldTab = table;
//保存旧的元素个数
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//保存旧的扩容阈值
int oldThr = threshold;
//设置新的容量、扩容阈值
int newCap, newThr = 0;
if (oldCap > 0) {
//旧的容量大于最大容量
if (oldCap >= MAXIMUM_CAPACITY) {
//扩容阀值设为Integer的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新的容量为旧的容量的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果旧容量小于等于16，新的阈值就是旧阈值的两倍
newThr = oldThr << 1;
}
//如果旧容量为 0 ，并且旧阈值>0，说明之前创建了哈希表但没有添加元素，初始化容量=阈值
else if (oldThr > 0)
newCap = oldThr;
else {
//旧容量、旧阈值都是0，说明还没创建哈希表，容量为默认容量，阈值=容量*加载因子
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值为 0 ，就得用 新容量*加载因子 重新计算一遍
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[] newTab = (Node[])new Node[newCap];
//将新数组给变量table
table = newTab;
//将暂存旧数据的OldTab变量的数据遍历复制回table变量
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
//旧的桶置为空
oldTab[j] = null;
//当前 桶 只有一个元素，直接赋值给对应位置
if (e.next == null)
//e.hash & (newCap - 1)=e.hash % newCap，重新索引
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果旧哈希表中这个位置的桶是树形结构，就要把新哈希表里当前桶也变成树形结构
((TreeNode)e).split(this, newTab, j, oldCap);
else {
//保留旧哈希表桶中链表的顺序
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;
}
============================================
get和remove没啥亮眼操作就意思意思了
============================================
get()
public V get(Object key) {
Node e;
//调用getNode，通过hash值和key来获得对应的值，如果没有，返回null
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
Node[] tab;
Node first, e;
int n;
K k;
//e.hash & (newCap - 1)=e.hash % newCap ，得到目标的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { //first指向hash值对应数组位置中的Node节点
if (first.hash == hash &&
// 如果first节点对应的hash和key的hash相等(在数组相同位置,只是说明 hash&(n-1) 操作结果相等,
//说明hash值的部分低位相等, 并不代表整个hash值相等), 并且first对应的key也相等的话, first节点就是要查找的
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) { //存在hash冲突
if (first instanceof TreeNode) //由红黑树对hash值冲突进行管理
return ((TreeNode)first).getTreeNode(hash, key); //查找红黑树
do { //hash值冲突是由链表进行管理
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null); //对链表进行遍历
}
}
return null;
}
remove()
public V remove(Object key) {
//临时变量
Node 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 removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
Node[] tab; Node 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 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)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)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;
}
注解：想必看到这张图就明白为什么了吧？
在这里插入图片描述