HashMap源码分析
分析之前需要知道的hashmap术语：
桶： 就是hashmap的table数组
bin: 就是挂在数组上的链表
TreeNode: 红黑树
capacity： table总容量（默认16）
loadFactor：负载因子（默认0.75）
threshold：键值对容量的上限 （threshold=capacity*loadFactor）
size：实际的键值对数量
MIN_TREEIFY_CAPACITY ：64 转化为红黑树table最小大小
TREEIFY_THRESHOLD ：8 转化为红黑树的阈值
一、问题分析
1、数据结构
2、增删改减操作的实现原理
3、扩容
4、hash冲突
二、数据结构
1、哈希表结构（数组（数组长度capacity默认初始为16）+链表+红黑树）
2、键值对类型为Node类型（实现了Map.Entry接口）
3、链表转换为红黑树条件（重点）
（1）链表长度大于等于8（ TREEIFY_THRESHOLD），调用treeifyBin()方法
（2）在treeifyBin方法里，如果数组（桶）的容量小于64，则扩容resize()不转换
三、增删改查操作的原理
1、确定哈希桶数组索引位置
取key的hashCode值、高位运算
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}2、put()方法
流程：
（1）判断table数组是否为空，如为空，则扩容resize()
（2）根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向(4)，如果 table[i]不为空，转向(3)
（3）判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向(4)，这里的相同指的是 hashCode以及equals；
（4）判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如是红黑树，则直接在树中插入键值对，否则转(5)
（5）遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进 行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可
（6）插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容
源码如下：
1 public V put(K key, V value) {
2 // 对key的hashCode()做hash
3 return putVal(hash(key), key, value, false, true);
4 }
5
6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
7 boolean evict) {
8 Node[] tab; Node p; int n, i;
9 // 步骤①：tab为空则创建
10 if ((tab = table) == null || (n = tab.length) == 0)
11 n = (tab = resize()).length;
12 // 步骤②：计算index，并对null做处理
13 if ((p = tab[i = (n - 1) & hash]) == null)
14 tab[i] = newNode(hash, key, value, null);
15 else {
16 Node e; K k;
17 // 步骤③：节点key存在，直接覆盖value
18 if (p.hash == hash &&
19 ((k = p.key) == key || (key != null && key.equals(k))))
20 e = p;
21 // 步骤④：判断该链为红黑树
22 else if (p instanceof TreeNode)
23 e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
24 // 步骤⑤：该链为链表
25 else {
26 for (int binCount = 0; ; ++binCount) {
27 if ((e = p.next) == null) {
28 p.next = newNode(hash, key,value,null);
//链表长度大于8转换为红黑树进行处理
29 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
30 treeifyBin(tab, hash);
31 break;
32 }
// key已经存在直接覆盖value
33 if (e.hash == hash &&
34 ((k = e.key) == key || (key != null && key.equals(k)))) break;
36 p = e;
37 }
38 }
39
40 if (e != null) { // existing mapping for key
41 V oldValue = e.value;
42 if (!onlyIfAbsent || oldValue == null)
43 e.value = value;
44 afterNodeAccess(e);
45 return oldValue;
46 }
47 }
48 ++modCount;
49 // 步骤⑥：超过最大容量 就扩容
50 if (++size > threshold)
51 resize();
52 afterNodeInsertion(evict);
53 return null;
54 } 四、扩容
分三步
第一步：
判断table（桶）是否为空，若oldcap大于0，首先如果超过了数组的最大容量，那么就直接将阈值设置为整数最大 值，然后如果没有超过，那就扩容为原来的2倍，这里要注意是oldThr << 1，移位操作来实现的
//第一部分：扩容
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表示如果table为空且阈值已经初始化过了，那就直接使用旧的阈值。然后第二个else表示如果 没有初始化，那就初始化一个新的数组容量和新的阈值
//第二部分：设置阈值
else if (oldThr > 0) //阈值已经初始化了，就直接使用
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[] newTab = (Node[])new Node[newCap];
table = newTab; 第三步：
将旧数据保存到新数据中
源码如下：
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) {
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) // 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[] newTab = (Node[])new Node[newCap];
table = newTab;
//第三部分：旧数据保存在新数组里面
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node 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)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);
//链表1存于原索引
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//链表2存于原索引加上原hash桶长度的偏移量
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
} 五、hash冲突
hashMap中处理hash冲突的方法就是链地址法