JDK1.8HashMap源码阅读
首先介绍一下HashMap的put和get的整体流程。然后记录了一些相关的问题点。文章最后是源代码的逐行阅读。
整体流程
put流程
1.我们调用put方法，进入方法中。先将hashcode进行一个扰动，与右移16位后的值异或，得到一个int类型的hash
2.先判断一下数组是否存在，如果不存在，先进入resize方法，进行数组的初始化
3.用hash进行散列，将hash和（length-1）相与得到数组下标
4.如果数组该位置为空，将新节点放到该位置
5.如果该位置不为空，但是key相同，就会将该节点的value替换掉
6.如果该位置不为空，key也不同，就会开始遍历链表，如果链表中有相同的key，就会替换节点的value，如果没有，则在尾部插入一个节点
7.然后会判断一下链表长度是否大于8，如果是，那么会进入树化的方法，如果数组长度小于64，只进行扩容，否则树化
8.接着将size+1，如果size大于阈值，进入resize方法进行扩容
get流程
1.对hashcode进行扰动，然后通过hash值计算得到数组下标
2.如果该下标没有节点，返回null
3.如果有节点，先检查第一个节点key是否相同。相同的话返回第一个节点
4.然后判断节点类型，决定是树的遍历方法还是链表的遍历方法
5.遍历完后，找到key相同的就返回value，没有就返回null
一些问题点
1.为什么默认的加载因子是0.75 ？
这是数组的空间利用率和查询效率的折衷。map中键值对个数达到(数组大小*加载因子)就会扩容，加载因子太小的话数组很多空间都浪费了，太大的话hash碰撞会比较激烈。
(ps:所以我们在知道将要存储多少个键值对的时候，应该初始化容量为n/0.75,向上取最近的2的次幂，来防止map内部的数组频繁扩容，当然这个取2的次幂的工作可以由hashmap来做)
2.为什么要用 hash&(数组长度-1) 这样的方式来散列？
因为用hash和数组长度取模%运算的效率比较低。所以采用了用2的次幂掩码的方式来散列。
解释一下这种采用掩码的散列方式:
HashMap map =new HashMap();
map.put(8,"aaa");
初始的数组长度是16
假设得到的hash是8（由于进行了扰动，put 8 得到的hash其实是个很大的值）
| 值 | 二进制 | 散列结果 | 数组下标 |
|---|---|---|---|
| 16-1 | 0000 1111 | ||
| hash=8 | 0000 1000 | 1000 | 8 |
| hash=20 | 0001 0100 | 0100 | 4 |
| hash=60 | 0011 1100 | 1100 | 12 |
| hash=56 | 0011 1000 | 1000 | 8 |
可以看到hash & (数组长度-1) 这种方式就是取了hash的低位来确定数组的索引。数组长度为16的话就是取了低4位。4个1和任何int相&的范围是[0,15]，正好对应了数组的下标
key的hash=8和hash=56的二进制低四位是相同的，所以它们会被散列到同一个数组下标，这就是哈希碰撞了，依次往map里放的话会构建一个链表
3.为什么容量是2的次幂?
为了方便采用掩码的方式来散列。还有扩容的时候，也是采用掩码的方式
看懂了上面的散列方式，这个问题就很简单了。2的次幂就是1往左移。
比如16就是 1 << 4 : 1 0000 减个1就是4个1了:1111
32就是 1 << 5 :10 0000 减个1就是5个1了：1 1111
4.为什么要将hashCode与右移16位后的值异或？
(h = key.hashCode()) ^ (h >>> 16)
将哈希值的高位扩展到低位。因为散列的方式是采用2次幂掩码的方式，在数组长度比较小的时候只有低位参与了运算。
源代码
put方法
public static void main(String[] args) {
HashMap h =new HashMap();
h.put(8,"aaa");//写一个main函数，debug进入，阅读
}
下面进入put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);//先进hash这个方法看一下
}
计算hash
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);//可以看到，key可以是null，hash值是0
}//(h = key.hashCode()) ^ (h >>> 16)就是将高位扩展到低位
hash(Object key)这个方法返回了一个int值，用于散列，确定数组下标
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;//resize()数组扩容的方法，等会再来看
if ((p = tab[i = (n - 1) & hash]) == null)//(n - 1) & hash这里，比如容量是16,就是将hash与上1111,取了低4位的值
tab[i] = newNode(hash, key, value, null);//数组该位置为空的话，直接放置一个新节点
else {
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))//如果key相同的话，将原先的节点赋给e
e = p;
else if (p instanceof TreeNode)//如果是一个树节点的，就往红黑树上加节点
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {//key不相同处理,链表
for (int binCount = 0; ; ++binCount) {//循环遍历链表
if ((e = p.next) == null) {//将原先那个节点的后一个赋给e,//e看成是快指针
p.next = newNode(hash, key, value, null);//往末尾插入了一个节点
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//在链表插入第9个元素后，binCount=7,进入树化方法
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))//如果指针e指向的节点key值相同，跳出循环，下面会替换该节点的value值
break;
p = e;//指针往后移一位
}
}
if (e != null) { // existing mapping for key//e不为空时指向要替换的键值对
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)//size+1,然后键值对个数大于阈值的话，扩容
resize();
afterNodeInsertion(evict);
return null;
}
然后看一下扩容的方法resize()
final Node[] resize() {
Node[] 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;//那么阈值就设置成int最大值，比数组大,这样就不会频繁触发扩容了
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&//新容量为老容量乘2
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold阈值乘2
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//如果我们自己往构造器中传入了初始容量的话，会用我们的容量来初始化
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//否则就初始化为16个大小的数组
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[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {//旧数组不为空，需要进行数据的迁移
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {//e指向数组第一个节点开始
oldTab[j] = null;//帮助gc
if (e.next == null)//只有一个元素
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//容量都是按照位左移扩容的，所以oldCap=16是 1 0000,与运算可以取到第5位。高一位是0的放一起
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {//高一位是1的放一起
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;
}
get方法
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}//这个从getNode方法获取一个节点，返回节点的value
看一下getNode方法
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {//散列，确定数组下标，头节点赋给first。头节点为空就到最后return null了
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))//判断第一个节点的hash是否相等，然后equals判断
return first;
if ((e = first.next) != null) {//头节点下面还挂了节点的话
if (first instanceof TreeNode)//从树中找节点
return ((TreeNode)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;
}
带参数的构造器
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);//tableSizeFor方法对我们传入的参数进行了处理，最后处理结果是2的次幂,赋给了threshold，在数组初始化的时候用得到
}