- 此文章缘由第一次面试阿里。
- 20180926：之前匆忙整理出关键知识，发现逻辑有些混乱，这次干脆重新整理一遍。
概述
在JDK6、7中，HashMap使用的是数组+链表实现的，在JDK8中，使用的是数组+链表+红黑树实现。这种转变是为了解决当散列到一个桶内的元素过多时，提高查找效率。
图片来源：http://www.importnew.com/28263.html
关键源码解析
类继承关系
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
HashMap继承了AbstractMap，实现了Map、Cloneable、Serializable接口。
类成员变量
// 用于序列化的序列号信息
private static final long serialVersionUID = 362498820763181265L;
//默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量为2³°
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当桶上的节点数大于8的时候会转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
//当桶上的节点数小于6的时候会从树转为链表
static final int UNTREEIFY_THRESHOLD = 6;
//树化的最小表容量。如果容量小于64，即使某个桶的节点数目大于8，也不会进行树化，而是进行resize()
static final int MIN_TREEIFY_CAPACITY = 64;
//存放节点的数组，大小总是2的整数次幂，数组的每个索引位置又称为桶
transient Node<K,V>[] table;
//缓存了HashMap中节点的set集合
transient Set<Map.Entry<K,V>> entrySet;
//存放的节点数量
transient int size;
//记录结构上修改的次数，会用于fail-fast(快速报错，是指当一个线程在使用iterator进行迭代，
//有其他线程进行了结构性修改，那么这个迭代线程会抛出并发修改的异常ConcurrentModificationException
//所谓结构性修改，是对原有容器的size造成影响的操作，如remove、add、clear操作等 )
transient int modCount;
//临界值，当实际节点数目超过临界值（容量*负载因子），需要进行扩容
int threshold;
//负载因子=实际节点数/容量
final float loadFactor;
构造函数
//构造一个空的HashMap，初始化容量为16，初始化负载因子为0.75
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//以指定的容量初始化一个空的HashMap
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//以指定的容量和负载因子来初始化一个空的HashMap
public HashMap(int initialCapacity, float loadFactor) {
//初始容量需要大于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//当指定的初始容量大于最大值，则将初始容量置为最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//填充因子不能小于或等于0，不能为非数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//通过tableSizeFor(cap)计算第一个不小于initialCapacity的2的整数次幂作为初始容量，
//将其先保存在threshold里，当put时判断数组为空会调用resize分配内存，并重新计算正确的threshold
this.threshold = tableSizeFor(initialCapacity);
}
//根据指定的Map来初始化HashMap，容量和负载因子都使用默认值
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
节点类的实现
static class Node<K,V> implements Map.Entry<K,V> {
//对key进行hash()计算后得到的值
final int hash;
final K key;
V value;
Node<K,V> next;
//省略类中的方法
...
}
hash实现
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
Node中记录的hash值就是通过这个方法获取的，通过使key的hashCode()高16位不变，低16位与高16位做“异或（XOR）”作为最终hash值。
图片来源：https://blog.csdn.net/qazwyc/article/details/76686915
resize实现
//初始化table或者将table的容量扩充为当前的2倍
final Node<K,V>[] resize() {
//保存当前table
Node<K,V>[] oldTab = table;
//保存当前容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//保存当前阈值
int oldThr = threshold;
int newCap, newThr = 0;
//如果当前table容量大于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
}
//使用initialCapacity的构造函数的时候，容量信息是保存在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);
}
//初始化情况下，获取真正的阈值来覆盖之前保存在threshold中的初始容量
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"})
//新的table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将table置换为newTab
table = newTab;
//为新的table复制节点
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//将节点保存在e中
if ((e = oldTab[j]) != null) {
//手动为oldTab置null，让垃圾回收能够识别到该容器已经废弃
oldTab[j] = null;
//桶中只有一个节点
if (e.next == null)
//对该节点重新散列
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//头指针和尾指针
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//将同一桶中的元素根据(e.hash & oldCap)是否为0，
//分割成两个不同的链表，完成rehash
do {
next = e.next;
//和put操作的时候不同，这里直接使用容量来做按位与，因为容量是2的整数次幂，所以
//低位都是0，也就是说只有当节点的hash值与原容量的最高位对应的位置都为1的时候，
//该节点会被散列到数组新开辟出来的范围上
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//不在oldCap容量内，进行取模操作的hash节点，需要重新散列，这里先将
//这些节点保存到hi的队列中
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;
//hi队列中保存的节点的新散列即为原索引+oldCap
//这里开始的时候想差了，我自己举的oldCap=8，然后存在hash为9和17的两个节点
//9的新索引为原索引+原容量可以理解，但是17怎么变成9了而不是1呢？
//后来突然想通了，如果是17的话根本就进不到这个代码，也就是不可能变为9
//因为(e.hash & oldCap) == 0这个判断是为true的，17保留了原来的索引，也就是1
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
针对(e.hash & oldCap) == 0来划分lo链表和hi链表进行进一步说明：
当原来的容量为8时，散列的桶的索引为：
当进入(e.hash & oldCap) == 0的判断时：
所以，9是会进入到hi的链表中，而17依然在lo的链表中
put实现
put的大致过程如下：
public V put(K key, V value) {
//对key做hash
return putVal(hash(key), key, value, false, true);
}
public V putIfAbsent(K key, V value) {
//对key做hash
return putVal(hash(key), key, value, true, true);
}
//参数onlyIfAbsent为true时，只有不存在该key时才进行put操作
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//第一次put的时候进行初始化操作，这里参看resize()中的过程
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//散列的位置为(n-1)&hash，判断此处的桶是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
//如果为null，就将新节点插入
tab[i] = newNode(hash, key, value, null);
//如果该桶内已经有数据
else {
Node<K,V> e; K k;
//与桶内第一个节点的hash相等，key相等
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);
//如果达到树化的阈值，转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果已经存在相同的key了，就不需要遍历到链表的尾部了
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果存在相同的key，上面的循环不会循环到链表尾部，(e=p.next)!=null
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//实际节点数大于阈值，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
get实现
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//比较桶中的第一个节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//桶中不止一个节点
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
小结
-
在存在hash冲突时，JDK7和JDK8的put操作插入的位置有所不同：JDK7会插在桶的第一个节点，即链表的头部；而在JDK8中会插在桶的最后一个元素，即链表的尾部
-
key的不可变。通常使用String对象，或者封装基本类型来作为HashMap的key是合适的，因为它们都是final的，且重写了hashCode和equals方法。key的不可变是必要的，如果在存取过程中key值发生改变，且计算出的hashCode发生了改变，那么就无法找到你期望得到的对象。
-
put操作时，JDK8中是先插入节点，然后如果判断超出阈值，那么再进行扩容；JDK6、7中是先扩容再插入节点。
-
重写hashCode和equals方法是很重要的。良好的hashCode方法能在对象不同的情况下返回不同的值，减少了碰撞的几率，能够提高HashMap的效率（因为这样就完全等于在数组中查找了）。equals方法则规定了进入桶后，在链表中进行比较的规则。再次强调下重写equals()方法后重写hashCode()的必要性：在Object类中，hashCode()方法是一个本地native方法，返回的是对象引用中存储的对象的内存地址，而equals方法是利用==来比较的也是对象的内存地址，此时如果没有对它们进行重写，它们之间是相互匹配的。
equals()和hashCode()之间存在如下关系：- 当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true ;
- 当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false;
假设现在对一个Person类的equals()方法进行了重写（比较int类型age），equals()比较的不再是地址，此时hashCode()方法就不满足上述关系了，那么就可能存在两个Person的age相同，equals()返回true，但是由于两个对象地址不同，hashCode()不相等，这是不满足约定的。
如果是在hashMap中，存在一个key，假设是Person实例p，它重写了equals()，此时将这个（key，value）放入hashMap中；然后new一个新的Person对象p2，它满足p.equals(p2)==true，但是由于hashCode()方法未被重写，在调用hashMap的get方法是，取得p2的哈希值与p不一样，也就是p2散列到了与p不同的桶中，在这种情况下就取不出想要的value值了。 -
关于hashMap的容量为什么是2的整数次幂，我总结为如下3条：
- 因为
threshold=loadFactor*capacity，大多数情况下，loadFactor不进行修改，即默认值0.75，也就是3/4，如果容量为2的整数次幂，这样在计算阈值的时候会比较方便。 - 在进行put操作时，对Node进行散列，获取桶下标的方法是：
p = tab[i = (n - 1) & hash]（n代表hashMap的容量），因为n是2的整数次幂，减一后就全是1了，例如(8)2=1000，减1后为111，这样再做与操作实际上等同于取余操作，但是效率比%高很多（20190401更新：试了下，其实也没高出很多，只有很小的提高，重复Integer.MAX次进行计算，也不过才快出了几毫秒）。 - 在进行resize的时候，需要对hashMap中的Node进行重新散列，这里分为两个链表，lo和hi，区分Node重新散列到lo还是hi的条件是
(e.hash & oldCap) == 0，注意和put操作时候的散列的区别是这里没有对容量减1，这其实相当于扩容2倍后，即容量值左移1位，如果进行&计算依然为0，说明要么这个Node的hash值本身在lo中，要么扩容后（左移1位后）依然无法散列到新的空间上去。
- 因为
参考文章：
274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
