源码分析：逐行分析HashMap
概述：HashMap 键值对、无序、非线程安全、效率高
HashMap允许null值（key和value都允许） key不能重复
数据结构 在 1.7及之前是：数组加链表 1.8是：数组加链表/红黑树
优缺点：
- 数组 -- 查询效率 O(1) 能直接通过hash值找到位置 不用做其他操作
不过数组的长度是固定的 如果超出长度 需要进行扩容 而数组扩容是一个比较消耗性能的操作
总结：在HashMap中最好一开始指定好长度 减少扩容 - 链表 -- 查询效率 O(n) 需要通过循环 一个个链过去 不能直接找到数据
在1.7的JDK中 链表是通过头插入的 在1.8的JDK中 链表是通过尾插入的 尾插入属于优化
头插的优点在于：比尾插效率更高 不需要遍历找到最后一个节点 只需要把新节点的下一个指向原头节点 把hash桶中的引用改为新节点
头插的缺点在于：在多线程的情况下 多个线程一起扩容的时候可能会造成一个循环链表 循环链表会导致永远找不到尾节点 导致死循环
总结：在HashMap中链表的长度最好控制的比较低 因为长链表影响查询效率 HashMap中给出的长度是8超过就要考虑树化 长度低于6就会转成链表 - 红黑树 -- 查询效率 O(log(n)) 需要通过树来查找 决定效率的是树的深度
因为红黑树的特性：左子节点比根节点小 右子节点比根节点大 可以在查询的时候减少查询次数
总结：红黑树是一个自平衡的二叉树 在HashMap中最好不要用到 虽然他会提高链表过长导致的查询效率问题（链表过长的情况很少出现 hash碰撞的概率还是比较小的）
但它是自平衡的 所以需要考虑在插入和删除数据的时候 维护平衡所带来的性能问题 左旋右旋 而且树节点比链表节点更大
另外需要注意的是HashMap中 树化需要两个条件 第一个是链表的长度超过8 第二个是数组的长度超过64 - 总结：
推荐在使用HashMap的时候 最好给一个初始化容量 减少数组扩容次数 提高性能 也能降低链表的长度 最好不要使用到红黑树
源码解析：
关系结构：
HashMap内部结构：
常量：
// 数组默认容量 2的四次方 位运算 16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 数组最大容量 2的三十次方 Integer的最大值 但这是hash桶的最大值 并不是hashmap的最大值 到这个最大值hash桶就不会再扩容
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;
// 触发树化的最小hash桶值 触发树化的第二个决定条件 hash桶的长度最少要有64才华
static final int MIN_TREEIFY_CAPACITY = 64;
变量：
// Hash桶对象
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
// 逻辑长度
transient int size;
// 修改次数
transient int modCount;
// 数组容器扩容阈值
int threshold;
// 实际的负载因子
final float loadFactor;
添加：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 实际的添加数据方法
// 参数：key的hash值 | key | value | 是否覆盖值 |
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// tab hash桶的临时变量
// p hash桶中新数据需要存入的位置
// n hash桶长度的临时变量
// i 新数据需要存入的索引
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 首先把hash桶赋值给临时变量tab 然后判断hash桶是否为null 或者hash桶长度为零
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;// 符合条件说明 hash桶需要通过resize方法调整大小 最终把调整后的大小赋值给变量n
// 从hash桶中取数据 数据位置是根据 hash桶长度和key的hash值 求出来的：(n - 1) & hash
if ((p = tab[i = (n - 1) & hash]) == null)// p的位置 数据为null 说明没有数据
tab[i] = newNode(hash, key, value, null);// 直接将新数据 创建成node节点存入
else {// p位置 不为null 说明存在数据
Node<K,V> e; K k;
// p的hash 等于 新数据的hash 并且 （新数据的key等于p的key 或者 他们equals相等）
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))// 键相等 说明是需要覆盖数据
e = p;// 直接把p赋值给变量e
else if (p instanceof TreeNode)// 如果p是树节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);// 执行树节点的数据存入
else {// 不符合以上两种情况 说明：需要以链表的形式存入数据
for (int binCount = 0; ; ++binCount) {// 死循环 只有break跳出
// 通过赋值 e是p的下一节点
if ((e = p.next) == null) {// p的下一节点为null
p.next = newNode(hash, key, value, null);// 将p的下一节点指向新数据
if (binCount >= TREEIFY_THRESHOLD - 1) // 判断链表是否需要树化
treeifyBin(tab, hash);// 树化操作
break;// 结束循环
}
// e的hash等于新数据的hash 并且 （e的key等于新数据的key）
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;// 新数据等于链表上的一个节点数据 结束循环
p = e;//不符合 上面两种情况 把e赋值给p p变成了自己的下一节点
}
// for循环中 第一个if判断的是下一节点为null没有数据 直接把新数据赋值上去 属于新增操作
// 第二个if判断的是下一节点的key和新数据的key相等 属于修改操作
}
// 通过上面的判断
// 1- e可能是hash桶中的第一个节点
// 2- e可能是树节点
// 3- e可能是链表上的节点
if (e != null) {// e不为空 上面三种情况下e不为null 只会是e是原本就存在的数据
V oldValue = e.value;// 先保留下e原本的数据 oldvalue
if (!onlyIfAbsent || oldValue == null)// 如果参数onlyIfAbsent为false 或者原数据为null
e.value = value;// 直接给e赋新值
afterNodeAccess(e);// 预留位置
return oldValue;// 返回被覆盖的原数据
}
}
++modCount;// 记录修改次数
if (++size > threshold)// 判断逻辑长度是否大于阈值
resize();// 大于阈值的化 调整容器尺寸
afterNodeInsertion(evict);// 预留位置
return null;// 不是覆盖数据的情况 就返回null
}
// 这两个方法是预留的位置 在LinkedHashMap中有实现
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
// 容器尺寸调整
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;// 阈值最大只能是Integer的最大值 因为threshold是int类型
return oldTab;// 直接返回原数组容器
}
// 通过旧长度计算出新长度 如果新长度小于数组容器最大值 并且 旧长度大于默认数组容器大小
// 扩容的大小是 oldCap << 1 左移一位 也就是扩容两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 这种情况下计算出来的 新长度 = oldCap << 1 新阈值 = oldThr << 1
}
else if (oldThr > 0) // 如果原阈值 大于零 原数组容器等于零 （说明是hashmap刚刚初始化）
newCap = oldThr;// 直接将原阈值 赋给新长度
else {// 原阈值 原数组容器长度 都为零 一切都取默认值
newCap = DEFAULT_INITIAL_CAPACITY;// 新长度取默认长度
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);// 新阈值取 默认负载因子 乘 默认长度
}
if (newThr == 0) {// 如果 新阈值为零
float ft = (float)newCap * loadFactor;// 新长度 乘 负载因子
// 新阈值 = 新长度小于容器最大长度 并且 新长度乘负载因子小于容器最大长度 为真取计算结果 为假取Integer最大值
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) {// 原hash桶节点赋值e e不为空
oldTab[j] = null;// 原节点先置空
if (e.next == null)// 如果 原节点不存在下一节点 只有一层
newTab[e.hash & (newCap - 1)] = e;// 直接在新数组容器中存放e
else if (e instanceof TreeNode)// 如果e是树节点类型
((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;// 下一节点
do {
next = e.next;
if ((e.hash & oldCap) == 0) {// 如果e在hash桶数组容器中的位置是0 需要考虑null的情况
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;
}
// treeifyBin 树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
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);// 把该节点连接的所有节点组成一棵树（树化的过程）
}
}
删除：
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}
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;
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;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
node = p;// 如果直接能在hash桶数组容器中查到 直接赋值给node
else if ((e = p.next) != null) {// 不在hash桶中 也就是要么在树节点上 要么在链表上
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 = e;
} while ((e = e.next) != null);// 循环取链表上节点
}
}
if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {
if (node instanceof TreeNode)// 如果是树节点 通过树节点的删除方法删除
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)// 如果是hash桶中的头节点 直接把hash桶中的位置指向头节点
tab[index] = node.next;
else// 把上一节点的下一节点指向node的下一节点
p.next = node.next;
++modCount;// 记录修改次数
--size;// 逻辑长度减一
afterNodeRemoval(node);// 预留位置
return node;// 返回删除的节点
}
}
return null;
}
总结：hashmap在1.7和1.8之间的区别
1.7是数组加链表
1.8是数组加链表加红黑树
