java中HashMap非常常用，HashMap针对效率做了很多方面的优化。无论是从使用角度还是从学习角度，分析一下HashMap的源码对我们都有很大帮助。可以让我们更好的掌握HashMap的使用方式，也能从中借鉴一些编程方法。这里主要写一下扩容resize方法。感觉这里有一些比较有意思的点。由于各个版本的HashMap实现方式有很大的区别，这里写的是针对jdk1.8的分析。
位运算
HashMap中使用了很多的位运算，所以先简单介绍一下位运算，否则如果对位运算不熟悉的话，碰到这种代码: tab[i = (n - 1) & hash] 有可能会不知所云，为了更好的理解代码，简单介绍一下这次会用到的两个位运算：&(与)和<<(左移)
（1）&(与)
1 & 1 = 1
1 & 0 = 0
0 & 0 = 0
对于 a & b ， 仅当a,b都为1 结果为1，否者为0。
用途： 用来取二进制序列的某些位。例如, 二进制序列，a=1001101
想要取右四位，可以 a & 1111 = 0001101;
想要取右1,3,5位，可以 a & 10101 = 0000101;
想要取的为为1，其他为零，与原数做 & 运算即可。
（2）<<(左移)
10101 << 2 = 1010100, 左移很简单，每一位都向左移动固定位，右面位补零。
用途是可以放大一定倍数，左移以为相当于 原数 * 2。HashMap中的数组扩容就是用的 << 运算将数组容量扩大二倍的。
HashMap数据结构
1.8之后的数据结构为数组和链表或者红黑树。
结构图：
- 扩容
第一次调用HashMap的put方法的时候，会调用resize()方法，初始化数组容量和元素个数阈值。
newCap = DEFAULT_INITIAL_CAPACITY; // 数组容量 1<<4 = 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 元素个数阈值，0.75f * 16 = 12 ,也就是hashMap中存放12个元素之后，就会第二次扩容@SuppressWarnings({"rawtypes","unchecked"}这行代码之前主要是为了计算新的数组容量和元素个数阈值，之后是新建了一个新的数组，并将原数组元素放到新数组中。
所以HashMap扩容成本是很高的，如果可以实现很确定的知道元素容量，最好可以事先指定容量。
下面是resize()方法的源码：
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)
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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
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
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> 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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}源码里面的if，else分支慢慢跟进比较好理解，树的部分比较复杂，可以单独拿出来好好研究研究，这里就分析一下链表的复制过程，复制过程比较巧妙。
主要代码如下，这里截取了for循环中的一部分。
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> 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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}正常的扩容逻辑应该是建一个新的更大的数组，然后把原数组包括链表和树中的元素，重新散列到新的数组中。但是这里有个巧妙的地方。HashMap中没有采用 hash(key) % table.length 这种方式来计算key的数组下标，而是采用了这种计算方式： (table.length - 1) & hash，& 的作用前面有讲是可以截取原数的某些位，如果table.length = 16, 16 -1 = 15 ，15的二进制为：1111，所以 1111 & hash 就是截取hash的右四位。举个例子：
原table.length = 16, 因为扩容方式是 length << 1, 所以扩容后 table.legtb = 32;
有两个key，hash之后的值分别为：
- hash(key1) = 10101110
原数组下标计算：
(table.length - 1) & hash = （16-1）& 10101110 全部转为二进制是
(10000 - 1) & 10101110 = 1111 & 10101110 = 00001110
扩容后数组下标计算：
(100000 - 1) & 10101110 = 11111 & 10101110 = 00001110
- hash(key2) = 10111110
原数组下标计算：
(10000 - 1) & 10111110 = 1111 & 10111110 = 00001110
扩容后数组下标计算：
(100000 - 1) & 10111110 = 11111 & 10111110 = 00011110
不知道大家有没有发现一个有意思的现象， key1的数组下标在扩容前后没有变化，key2的数组下标扩容后比扩容前多16。这并不是一个巧合。原因是每次扩容都是 << 1 左移一位，所以 hash & length 时，就拿这个例子来讲，原数组下标是截取hash右四位，新数组下标是截取hash右5位。
所以当右边第5位为0的时候，截4位和截5位结果相同，也就是扩容前后取得了相同的数组下标。
当第5位为1的时候，截4位是1110，截5位是11110，差值是 11110 - 1110 = 10000 （十进制 16）。也就是原数组容量。
简单来讲计算元素在新数组中的下标的时候，可以根据第5位的值来判断：（这个5指的是这个例子而言，实际取哪个位是根据数组容量来定的）
第5位为0： 新数组下标 = 原数组下标
第5位为1： 新数组下标 = 原数组下标 + 原数组长度
代码的判断方式就是这样的：
if ((e.hash & oldCap) == 0)
这也就是选中的这段代码的意思。整个这段代码的意思，其实就是把原数组中的一个链表，拆分成两个链表。 分别放到新数组中的 “原下标” 和 “原下标+原数组长度” 中 (loHead,loTail 和 hiHead,hiTail 分别指向两个链表的头尾节点)。理由就是上面讲的这个比较巧妙的思路，一个元素在新数组的下标只有这两种可能。这样就避免了每个元素都要单独计算，并重新放到新数组中。如果hash冲突比较严重的话，存在大量的链表和红黑树结构，一个元素一个元素的放到新的链表和树结构中，效率上明显是比较差的。
327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
