1 简介
HashMap主要用来存放键值对，基于Map接口实现。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树），以减少搜索时间。
2 源码分析
2.1 属性分析
// 默认初始容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 当桶（bucket）上的节点大于这个值时转为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当（桶）上节点数小于这个值时由树转化为链表
static final int UNTREEIFY_THRESHOLD = 6;
// 当桶的数组大小小于64的是偶，优先扩容，而不是转化为红黑树，也就是桶大小超过64后才会开始生成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
// 内部Node类，包含key，value和next指针，指向下一个Node
static class Node<K,V> implements Map.Entry<K,V> {}
// 存储元素的数组，容量总是2的幂次倍
transient Node<K,V>[] table;
// 存放具体元素的集 ？？？？
transient Set<Map.Entry<K,V>> entrySet;
// 存放元素的个数，不等于数组的长度
transient int size;
// 每次扩容和更改map结构的计数器，更新旧值不会增加
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
// 负载因子 一旦初始化，便不能更改
final float loadFactor;
2.1 构造方法
// 构造方法1 空构造方法
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 构造方法2，传入初始容量，调用构造方法3
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 构造方法3 传入初始容量 和 负载因子
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;
this.threshold = tableSizeFor(initialCapacity);
}
// 构造方法4 将已有的Map总的值映射拷贝到自己的存储中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
四个构造方法中，常用的是第一个。将loadFactor设置为默认值0.75。
其实HashMap类中并没有一个initialCapacity的变量，其实传入的initialCapacity变量用到了tableSizeFor()方法中，是用来确定threshold变量的。
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
2.3 hash方法与桶定位
hash方法
JDK1.7
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
JDK1.8
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
JDK1.8的hash方法相比于7方法简化了。通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)
桶定位
通过hash & (table.length -1)来得到该对象在桶中的位置。而HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
2.4 put方法
用户外部调用put方法，实际方法内部调用putVal()
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// table未初始化或者长度为0，进行扩容。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// (n - 1) & hash 确定元素该放在哪个桶，桶为空的话，就新建一个Node节点放入桶中
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 桶中已经存在元素
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //桶中第一个节点的key与hash值与新元素相同
e = p; // 将第一个元素赋值给e，用e来记录
else if (p instanceof TreeNode) // 桶中第一个节点的key不相等；但是桶第一个节点是树节点
// 放入树中
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);
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不为空，代表在桶中找到key值、hash值与插入元素相等的结点
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue; // e不为空，说明只是更新旧值，结构不会发生变化
}
}
// e不为空，说明插入了新值，modCount需要加1
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
2.5 resize方法
1 final Node<K,V>[] resize() {
2 Node<K,V>[] oldTab = table;
3 int oldCap = (oldTab == null) ? 0 : oldTab.length;
4 int oldThr = threshold;
5 int newCap, newThr = 0;
6 if (oldCap > 0) {
7 // 超过最大值就不再扩充了，就只好随你碰撞去吧
8 if (oldCap >= MAXIMUM_CAPACITY) {
9 threshold = Integer.MAX_VALUE;
10 return oldTab;
11 }
12 // 没超过最大值，就扩充为原来的2倍
13 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
14 oldCap >= DEFAULT_INITIAL_CAPACITY)
15 newThr = oldThr << 1; // double threshold
16 }
17 else if (oldThr > 0) // initial capacity was placed in threshold
18 newCap = oldThr;
19 else { // zero initial threshold signifies using defaults
20 newCap = DEFAULT_INITIAL_CAPACITY;
21 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
22 }
23 // 计算新的resize上限
24 if (newThr == 0) {
25
26 float ft = (float)newCap * loadFactor;
27 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
28 (int)ft : Integer.MAX_VALUE);
29 }
30 threshold = newThr;
31 @SuppressWarnings({"rawtypes"，"unchecked"})
32 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
33 table = newTab;
34 if (oldTab != null) {
35 // 把每个bucket都移动到新的buckets中
36 for (int j = 0; j < oldCap; ++j) {
37 Node<K,V> e;
38 if ((e = oldTab[j]) != null) {
39 oldTab[j] = null;
40 if (e.next == null)
41 newTab[e.hash & (newCap - 1)] = e;
42 else if (e instanceof TreeNode)
43 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
44 else { // 链表优化重hash的代码块
45 Node<K,V> loHead = null, loTail = null;
46 Node<K,V> hiHead = null, hiTail = null;
47 Node<K,V> next;
48 do {
49 next = e.next;
50 // 原索引
51 if ((e.hash & oldCap) == 0) {
52 if (loTail == null)
53 loHead = e;
54 else
55 loTail.next = e;
56 loTail = e;
57 }
58 // 原索引+oldCap
59 else {
60 if (hiTail == null)
61 hiHead = e;
62 else
63 hiTail.next = e;
64 hiTail = e;
65 }
66 } while ((e = next) != null);
67 // 原索引放到bucket里
68 if (loTail != null) {
69 loTail.next = null;
70 newTab[j] = loHead;
71 }
72 // 原索引+oldCap放到bucket里
73 if (hiTail != null) {
74 hiTail.next = null;
75 newTab[j + oldCap] = hiHead;
76 }
77 }
78 }
79 }
80 }
81 return newTab;
82 }
3 常见问题
3.1 桶大小为什么总是2的倍数
1 加速确定元素在桶的位置
一个元素放到哪个桶中，是通过 “hash % capacity” 取模运算得到的余数来确定的。而取模的运算速度不是很快，而通过位运算：(capacity - 1) & hash这种运算方式可以得到跟取模一样的结果，而且速度比取模块多了。（见2.3桶定位中的图）
2 关系到resize后元素在newCap中的放置问题
我们知道元素是通过位运算(capacity - 1) & hash来确定在桶中位置的，如果扩大两倍后，如下图a是oldCapacity，b是newCapacity，新元素在桶中的位置要不就是原索引，要不就是原索引+oldCapacity。这样在resize时不用重新计算h & (length-1);这一步骤了，大大减少了时间。
3.2 负载因子为什么是0.75
提高空间利用率和 减少查询成本的折中，主要是泊松分布，0.75的话碰撞最小。
3.3 头插法和尾插法
1.7是头插法，为的可能是热点数据的利用，新加入的可能用的概率更到，所以在头部，获取的时候也可以更快获取。但是在resize后头尾的顺序就换更换，是个问题。（头插法还可能造成死循环问题）
1.8变成尾插法。
更多问题 见 面试：HashMap 夺命二十一问
本文参考
1 Java 8系列之重新认识HashMap 美团技术团队
2 JavaGuide
5268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
