JDK源码解析之HashMap

一、HashMap 简介

前面介绍了LinkedList和ArrayList两个常用的集合，这次介绍的是另外一个常用的集合HashMap。HashMap继承了AbstractMap， 实现了Map，Cloneable， Serializable接口，使用的是键(key)-值(value)对存储方式，key和value都允许为null，key不允许重复 。

二、 HashMap 的数据结构

JDK1.8之前的HashMap是使用数组 + 链表作为数据结构，利用key的hashCode来计算hash值，再跟数组长度 - 1进行按位与得出在数组的下标，但是因为计算出来的下标有可能一样，特别是在存储的数量多的情况下一样的几率就更高了，所以在JDK1.8之前使用链表来存储计算出来下标一样的元素。但是链表的查询速度较慢，在JDK1.8对HashMap做了优化，使用数组 + 链表 + 红黑树来存储，当链表的长度大于8的时候，会转成红黑树，红黑树是一种 平衡二叉查找树 ，有较高的查找性能，有兴趣的朋友可以去了解下。

三、HashMap 源码解析

HashMap的源码有2000多行，再加上笔者能力有限，所以接下来就对一些主要的方法和属性进行解析

（一） HashMap 的属性

// 默认的数组长度
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

// 数组最大长度 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;

// 在转变成树之前，还会有一次判断，当键-值对数量大于 64 才会转换。这是为了避免在哈希表建立初期，多个键-值对恰
// 好被放入了同一个链表中而导致不必要的转化
static final int MIN_TREEIFY_CAPACITY = 64;

// Node节点的数组，主要容器
transient Node<K,V>[] table;

//缓存entrySet()
transient Set<Map.Entry<K,V>> entrySet;

// HashMap的大小，也就是存储键-值对的数量
transient int size;

// HashMap修改的次数
transient int modCount;

// 阈值，threshold = 容量(table.length) * 加载因子, 当HashMap中存储的键-值对数量大于这个的时候进行扩容
int threshold;

// 加载因子，默认0.75f，加载因子越低的话容器中的空闲空间越多，冲突机会较少，查询较快
// 加载因子越高的话容器中填满的元素更多了，减少了空间的开销，但元素跟元素之间的冲突就多了，冲突的话
// 会生成链表或红黑树，所以查询就慢了
final float loadFactor;

（二） HashMap 的构造方法

// 带初始化容量和加载因子的构造函数
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);
}

// capacity必须满足2的N次方,如果在构造函数内指定的容量cap不满足,
// 通过下面的算法将其转换为大于n的最小的2的N次方数.
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;
}

// 带初始化容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

// 空参数构造函数
public HashMap() {
// 使用默认的加载因子
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

// 参数为Map的构造函数，将另外一个Map的元素添加到容器中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 将另外一个Map的元素添加到容器中
putMapEntries(m, false);
}

// 将另外一个Map的元素添加到容器中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
// 判断table是否为空
if (table == null) { // pre-size
// 未初始化，计算 m 的容量
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 如果计算出来的容量大于阈值，则初始化阈值
if (t > threshold)
threshold = tableSizeFor(t);
} // 已经初始化的，如果s 大于 阈值，则进行扩容
else if (s > threshold)
resize();
// 将m中的所有元素存入该实例中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}

（三） 方法解析

(1) hash 函数 :

说明：存进来的key通过该函数生成hash值

// 将key生成hash值
static final int hash(Object key) {
int h;
// 计算hash值 ：假如数组的长度是 16 ，那计算出元素在数组中的存储下标就是 hash & (16 - 1)
// 也是是 hash & 1111 ，如果有两个key，其生成的hashCode分别为ABCD0000（8个16进制，32位），0ADC0000
// 将这两个hashCode（先转成二进制）和 1111按位与的话,得到的结果都是0，但是这两个hashCode相差很多，但却
// 存在数组的同一个位置上，这样会导致链表过长，而影响查询速度，所以为了减少这种情况，所以这里使用h >>> 16（无符号右移）
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

(2) getNode 函数

说明： 在HashMap中的get方法就是调用该方法用key来获取value

// 通过key获取对应存放的节点
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// (n - 1) & hash 该元素在table中的下标，如果获取到不为null的话。
// 获取第一个（链表的头或者红黑树的root）判断key是否一样，一样的话直接返回
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash &&
((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;
}

(3) putVal 函数

说明： HashMap中的put方法就是调用该方法来插入值

//添加键值对
//如果onlyIfAbsent为true的话，不改变已经存在的值
// 如果evict为false的话，说明该HashMap是刚创建的
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为null的话重新创建一个table
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// n - 1 & hash 计算出该键值对存放的下标，如果该下标没有其他节点，则直接生成节点并存入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// e ：下面操作如果该key已经存在，则将该key对应的节点赋值给e
Node<K,V> e; K k;
// 如果key已经存在并且key对应的节点是在第一个的话，则使用已经存在的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 {
// 如果下标使用的是链表结构，则生成Node节点并添加到链表的尾部
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 如果链表长度大于8的话则转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果key已经存在的话，则使用已经存在的key的节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // 如果key存在的话则修改值，并返回旧值
V oldValue = e.value;
// 判断是否要修改
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 设置节点的值后回调
afterNodeAccess(e);
return oldValue;
}
}
// 修改次数 + 1
++modCount;
// 如果键值对个数超过阈值，则扩容
if (++size > threshold)
resize();
// 插入节点后回调
afterNodeInsertion(evict);
return null;
}

(4) resize 函数

说明：每一次扩容都会对遍历所有元素然后重新进行hash

// 重新设置数组（table）的大小，其实就是重新创建一个长度更大的数组
final Node<K,V>[] resize() {
// 获取旧的table
Node<K,V>[] oldTab = table;
// 获取旧数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取旧的map存储的阈值、
int oldThr = threshold;
// 定义新的数组长度和新的阈值
int newCap, newThr = 0;

if (oldCap > 0) {
//如果旧数组的长度已经达到最大长度，则不重新创建，继续使用旧的数组
if (oldCap >= MAXIMUM_CAPACITY) {
// 而阈值d 使用 int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 新的数组长度 * 2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 旧阈值 * 2
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
// 如果旧的数组长度为0，而阈值大于0的话，那新的数组长度赋值为阈值
newCap = oldThr;
else {               // zero initial threshold signifies using defaults
// 如果旧的数组长度为0并且阈值也是0的话，那新的数组长度为默认长度，
// 阈值为默认长度乘加载因子
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数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 将table赋值为新的Node数组
table = newTab;
// 如果旧table不为空的话，就数据移到新的table中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 遍历旧table获取各个Node
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 如果该下标的元素只有一个的话（就是没有不同的key生成的hash值
// 一样而映射到数组的同一个位置而生成链表或红黑树的情况下）
// 直接将该元素跟新的数组长度-1按位与生成新的下标并存入新数组中
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进行分割，分成两个链表
do {
next = e.next;
/**
* 假如旧数组的长度是8，二进制是1 0 0 0 ，数组的存储下标是0~7，
* 所以hash值应该跟7（二进制 1 1 1）进行按位与，获取到的下标才会在0~7之间,
* 那旧数组中元素存储的位置就是 hash & （8 - 1）。进行resize()后数组的长度变
* 为原来的2倍，也就是16（二进制是0 0 0 1 0 0 0 0），那新数组中的元素存储位置
* 是 hash & (16 - 1) => hash & 15 , 15的二进制是 1 1 1 1，可以看出跟15的按位与
* 对比原来的7的按位与就多了第4位的1，所以源码中直接使用了就数组的长度 1 0 0 0来进行
* 按位与，如果结果是0，说明该元素在新数组中的存放位置跟原来数组一样，如果是1的话，那在
* 新数组中的位置是原来位置加上就数组的长度
*
*/
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;
}

总结： 个人觉得加载因子的取值对HashMap的性能有很大的影响，如果加载因子的值比较小的话，那元素冲突的几率较小，所以查询的效率较高，但是加载因子太小会导致容器空闲空间较多，而且存储元素多的话会导致容器频繁扩容， 每次扩容都会遍历所有的元素进行rehash 。如果加载因子较大的话容器中填满的元素就越多了，减少了空间的开销，但是冲突几率较高，查询性能较低。 以上就是个人对HashMap的解析，在最后面那resize方法的最后一部分自己不能如何去表达所以写得不好， 所以请见谅！