HashMap源码剖析
1.jdk1.7相关源码
初始化
初始化的时候，hashMap默认是空的，如果没有设置初始化容量，则使用默认的容量16.
put()
在put()的时候，如果hashMap是空的，则初始化HashMap（容量默认值为16）,并设置下一次触发扩容的容量为 16(当前容量) * 0.75(负载系数) = 12
如果put的key是null，则把该key-value存到hashMap下标为0的位置
如果key不是0，则根据key生成hashCode，然后使用该hashCode和Entry数组长度减一按位与运算（保证计算到的下标一定在数据长度范围之内），得到相应的Entry数组下标。接着循环这个下标对应位置的链表，如果链表中的节点中存在hash值和当前key的hash值一样的，且key和当前key相等的，就把新的value放到该位置上，并返回oldValue；否则，就把当前key-value放入HashMap中。
在放入新的key-value的时候，如果当前hashMap的长度到达了容量阈值，且待存入的下标位置不为空时，则需要进行扩容。
扩容的时候先生成一个新的Entry数组，长度为原数组的两倍，然后把原数组的元素依次转移到新的数据中，在转移的过程中，使用头插法的方式。转移完之后，重新计算容量阈值（当前数组长度 * 负载系数0.75）
resize之后，重新计算新增元素key的hash，并计算新的下标位置，让后将key-value放入hashMap中（仍使用头插法）
2.jdk1.8之后相关源码
初始化
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
put()
详细见注释
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;
// 如果是第一次put，调用resize方法初始化Node数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果Node数组中，根据hash计算出数组的下标对应的值为空，则直接存入该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 如果根据hash计算出的数组下标位置的Node不为空
Node<K,V> e; K k;
// 如果该位置Node的key和当前待插入的key一样(hash相同，且调用equals方法相等)
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
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果上面匹配到了一样的key，则修改其value值为新值
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;
}
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 {
// 默认的数组大小16， 阈值为16*0.75=12
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 如果新阈值为0，则根据新的容量计算新的阈值
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 保存新的阈值
threshold = newThr;
// 创建新的Node数据
@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;
// 如果当前遍历的的Node数组下标位置不为空，则将数据转移到新的数组中
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 {
// 如果当前节点是一个链表，采用尾插法的方式移动老数组的数据到新数组中
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 如果当前元素重新计算下标后，在新数组的前半段，则使用尾插法构建一个新的链表
// 其中loHead指链表的头指针，loTail指链表的尾指针
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 如果当前元素重新计算下标后，在新数组的后半段，则使用尾插法构建一个新的链表
// 其中hiHead指链表的头指针，hiTail指链表的尾指针
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;
}
resize()转移Node数组元素时，如果当前Node指向的是一个红黑树，则进行以下处理
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
// 遍历红黑树
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
// 如果计算出当前节点在新数组中的新下标位置位于数组的前一半，则使用尾插法的方式记录下来
// 其中loHead是头指针，loTail是尾指针
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
// 如果计算出当前节点在新数组中的新下标位置位于数组的后一半，则使用尾插法的方式记录下来
// 其中hiHead是头指针，hiTail是尾指针
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
// 如果存在新的下标是位于新数组前一半的链表
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
// 其长度小于等于6,则转成链表，并直接存储在下标为在老数组原下标的位置
tab[index] = loHead.untreeify(map);
else {
// 长度大于6，则转成红黑树，并直接存储在下标为在老数组原下标的位置
tab[index] = loHead;
if (hiHead != null)
loHead.treeify(tab);
}
}
// 如果存在新的下标是位于新数组后一半的链表
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
// 其长度小于等于6,则转成链表，并存储在相对于老数组原下标偏移老数组长度的新的下标位置
tab[index + bit] = hiHead.untreeify(map);
else {
// 长度大于6，则转成红黑树，并存储在相对于老数组原下标偏移老数组长度的新的下标位置
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
总结
- 1.7之前在第一次put的时候，调用
inflateTable()来初始化数组。1.8之后是在第一次put的时候调用resize()方法初始化。 - 1.7之前底层结构时动态数组+链表的结构。1.8之后底层是动态数据+链表/红黑树的结构。当某个位置的链表长度大于等于8，就会转成红黑树。
- 1.7之前调用
put()时，在存入数据之前进行扩容。1.8之后是在存入数据之后，再进行扩容操作。 - 1.7之前插入链表的时候使用的是头插法。1.8之后使用的是尾插法。
- 1.7之前在数据扩容的时候，对原数组中的每个Entry进行遍历，对key重新计算hash值，然后和新的数组长度与运算得到出新的数组下标。1.8之后在扩容的时候，对原数组中的每个Node进行遍历,针对某一个Node节点下的链表或红黑树，使用高低位指针配合的方式，低位指针指向的链表仍存储在老数组的下标位置，高位指针指向的链表存储在（老数组的下标+老数组的容量）对应的下标位置