1. HashMap的初始化
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
HashMap
中的 Node
数组的初始大小。实例化一个 HashMap
对象后,Node
数组为null,只有在第一次往 HashMap
中put数据时,Node
数组才会初始化,初始化的大小就是 DEFAULT_INITIAL_CAPACITY
。
transient Node<K,V>[] table; // Node数组
public HashMap() {
// 构造函数中并没有初始化table数组
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
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;
if ((tab = table) == null || (n = tab.length) == 0) {
// 当 table == null 的时候,tab = resize(),也就是
n = (tab = resize()).length;
}
// ...
}
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) {
// ..
}
else if (oldThr > 0) // initial capacity was placed in threshold
// ..
else {
// 因为i刚开始 table == null && threshold == 0,所以走的是这里的逻辑
// 用 DEFAULT_INITIAL_CAPACITY(16)作为数组的初始化大小
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// ...
}
2. hash算法
/**
* Computes key.hashCode() and spreads (XORs) higher bits of hash
* to lower. Because the table uses power-of-two masking, sets of
* hashes that vary only in bits above the current mask will
* always collide. (Among known examples are sets of Float keys
* holding consecutive whole numbers in small tables.) So we
* apply a transform that spreads the impact of higher bits
* downward. There is a tradeoff between speed, utility, and
* quality of bit-spreading. Because many common sets of hashes
* are already reasonably distributed (so don't benefit from
* spreading), and because we use trees to handle large sets of
* collisions in bins, we just XOR some shifted bits in the
* cheapest possible way to reduce systematic lossage, as well as
* to incorporate impact of the highest bits that would otherwise
* never be used in index calculations because of table bounds.
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
h >>> 16
把h
右移16位,因为int是32位的,所以上面的运算就等价于将 h
的高16位和低16位进行异或,目的是为了降低hash冲突的概率。因为HashMap
中数组的长度总是2的倍数,所以对 hash()
结果进行取模时,其实就是取低位的多少位(比如如果数组的长度是16,那么就是取 hash()
结果的后4位,这种情况下,高位的二进制码就被屏蔽了,因此在计算槽位的时候会丢失高位的特征。现在的算法将低位和高位进行异或操作,可以把高位和低位的二进制码混合到低位,从而有助于降低hash冲突。
3. 扩容
/**
* The number of key-value mappings contained in this map.
*/
transient int size; // Map中有多少kjey-value对,如果这个数量达到了指定大小 * 负载因子
/**
* The next size value at which to resize (capacity * load factor).
*
* @serial
*/
int threshold;
/**
* The load factor for the hash table.
*
* @serial
*/
final float loadFactor;
/**
* 扩容方法
*/
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;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// newCap = oldCap * 2
// newThr = oldThr * 2
newThr = oldThr << 1;
}
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 新数组的大小是老数组的2倍
table = newTab; // table 等于扩容后的数组
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> 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<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// loHead 指向的是 j 这个索引后接的链表的头节点,loTail 指向的是尾节点
Node<K,V> loHead = null, loTail = null;
// hiHead 指向的是 j + oldCap 这个索引后接的链表的头节点,hiTail 指向的是尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
// 说明扩容后e这个节点仍然在 j 索引后接的链表上
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
// 说明扩容后e这个节点在 j + oldCap 这个索引后接的链表上
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;
}
size
代表了当前HashMap
中有多少键值对。如果 size
达到了 threshold
就会进行数组的扩容,threshold = capacity * loadFactor
。loadFactor
的默认大小是0.75,而capacity则是 table.length
。在HashMap
的构造函数中,可以自己指定 loadFactor
,但是一般情况下使用默认的就可以,但是数组的大小一般会自己指定下,避免频繁地扩容。
数组每次扩容后的长度都是2的指数(数组的初始长度时16,每次扩容都 * 2)。每次扩容后,链表(红黑树)中的节点都需要进行rehash。在JDK1.7中,会用hash对新数组的长度取模;但是在JDK1.8中,为了优化性能,也使用了上面提到的hash算法。因为JDK1.8中,数组扩容后的长度都是2的倍数,所以可以使用 hash & (n - 1)
来计算新的索引位置。更进一步地简化,比如原数组的长度是16(对应二进制为 10000
),那么新数组的长度是32(对应二进制为 100000
),那么 hash & (n - 1)
其实就等于 hash & (1111) + hash & (10000)
也就是 oldIndex + hash & oldCap
,所以只需要通过 (hash & oldCap) == 0
即可知道扩容后新的Index的位置。
4. put
/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 初始的时候,table == null,所以需要先执行一个扩容,分配一个默认大小的数组,数组大小是16
n = (tab = resize()).length;
// 高性能的hash运算,n表示数组长度(初次是16),那么 (n - 1) & hash 就是取hash的低几位
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果算出来的index位置为空,则 key-value 是这个index后接的链表的头节点
// 也就是说此时没有产生hash冲突
tab[i] = newNode(hash, key, value, null);
else {
// 此时产生了hash冲突
// e指向的就是和参数key相同key的节点,也就是要覆盖的节点,e == null说明是新增;e != null 说明是覆盖
Node<K,V> e; K k;
// 此时p就是链表的头部节点
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
// 如果p节点的hash值和key一样,且p节点的key和参数key相等
// 这个分支代表的是相同key的value覆盖
e = p;
else if (p instanceof TreeNode)
// 这个分支代表这个index后接的是一棵红黑树
// 将 (key, value) 插入红黑树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 这个分支代表这个index后接的是链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 这个分支代表已经到了链表的尾节点(null)
// 此时创建一个新节点,挂在链表的尾巴上
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// binCount 代表的是链表的长度 - 1
// 如果binCount >= 7(也就是链表的长度大于等于8,也就是说在新增节点前,链表中已经有8个节点了),就将链表转变成红黑树
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
// 这个分支代表链表中存在节点的key等于参数key,也就是此时要覆盖
break;
p = e;
}
}
if (e != null) { // existing mapping for key
// 如果 e 不为空,说明这个是覆盖,而不是新增
// 用 value 覆盖掉 e 中的旧的value,并且返回旧的value
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 后续LinkedHashMap等子类会用到
return oldValue;
}
}
// 此时 e 为null,说明之前执行的是新增节点
++modCount;
if (++size > threshold)
// 新增节点后,size需要+1,如果此时的新size > threshold,则需要执行扩容
resize();
afterNodeInsertion(evict);
return null;
}
因为数组的长度都是2的n次方,因此就可以保证 (n - 1) & hash
的结果与 hash % table.length
的结果始终相等。
从上面的代码可知,put
方法只有在插入数据(而不是更新数据)时才会判断是否需要将链表转换为红黑树。
5. 链表转红黑树
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
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
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
// tl 指向的是 p 节点的前一个节点,p指向的是当前节点
tl = p;
} while ((e = e.next) != null);
// 遍历结束后,hd仍然是一个链表,但是一个 TreeNode 组成的双向链表
// 就相当于把链表中的每一个节点都转换成了TreeNode,但是还没有把链表转成红黑树
if ((tab[index] = hd) != null)
// 将TreeNode双向链表转成红黑树
hd.treeify(tab);
}
}