一、tableSizeFor(int cap)
给定一个容量cap，返回第一个大于等于cap的为2的幂的数，也就是说无论给定的cap是多少，返回的都是2的幂。
tableSizeFor(int cap)方法代码如下所示：
static final int tableSizeFor(int cap) {
// -1是为了当cap本身就为2的幂时，退一位再运算，这样最后的n + 1才不会超过本身
// 举例：比如当cap = 2时，应该返回2，但是如果不-1的话，最后返回：11 + 1 = 100（4）
// 因为下面的位运算操作会将cap的二进制表示第一个为1以后的每一位都变为1
int n = cap - 1;
// 通过下面的或运算和无符号右移运算，可以将给定cap的二进制表示中为1的最高位后面的每1位
// 都变为，最后n + 1就会编程大于等于cap的第一个2的幂
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;
}
1.1|和>>>运算
|表示或运算，2个数进行运算，2个数对应的位中只要有一个1，对应的位就位1
>>>表示无符号右移动，比如 00000000 00000000 00000000 00000010 >>> 1
假如cap = 01000000 00000000 00000000 00000001
n = cap - 1 => 01000000 00000000 00000000 00000000
n |= n >>> 1 => 01100000 00000000 00000000 00000000，前面至少2个1
n |= n >>> 2 => 01111000 00000000 00000000 00000000，前面至少4个1
n |= n >>> 4 => 01111111 10000000 00000000 00000000，前面至少8个1
n |= n >>> 8 => 01111111 11111111 10000000 00000000，前面至少16个1
n |= n >>> 16 => 01111111 11111111 11111111 11111111，全都是1
由此可见通过以上的运算可以将一个数的最高位为1后续的每一位都变为1，最后+1就能获得第一个大于等于cap的2的幂，比如能将5变成7再加1就得到8。
1.2 int n = cap - 1的作用
当cap本身就已经是2的幂，比如1、2、4...的时候需要-1也就是退1位来参与运算，否则最后的运算结果将不会返回本身，而是返回本身*2。那是因为后续的|和>>>运算会将cap的二进制表示中的最高位为1后续的每一位都变为1。
举例说明，当cap = 5时，二进制表示为：
00000000 00000000 00000000 00000101
通过位运算后就会变为：
00000000 00000000 00000000 00000111
1.3 最大值为MAXIMUM_CAPACITY
static final int MAXIMUM_CAPACITY = 1 << 30;
二、hash(Object key)
使用key.hashCode()，并与其高位做异或（XORs）运算，最终计算出该key的hash值
- key运行为null，当key为null时，其hash为0
hash(Object key)的代码如下所示：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2.1 为啥会与高位做异或运算
通常情况下，表的大小为2的幂，而且表会比较小，小于2^16，此时如果直接用hashCode进行取模，将会丢失高位的特征，容易分布不均匀（如果一些hashCode的高位不同，而低位相同，则会产生冲突），我们知道hashCode返回的是一个int32的整数。将其无符号右移16位后就是该hashCode高位的特征，通过异或运算，将高低位特征结合，更加合理的分配，选用异或运算也是开销最小的方式。
三、构造函数
一共有3个构造函数，在调用构造函数时不会初始化保存对象的数组，只会设置相关的参数；我们需要记住这3个构造函数，根据使用的构造函数不同，在第一次调用put方法初始化tab时，所对应的初始化逻辑会有所不同。
3.1 可设置初始化容量和负载因子
使用该构造方法，会设置
threshold以及设置threshold为大于等于初始化容量的第一个2的幂
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);
}
3.2 可设置初始化容量，使用默认的负载因子
同上一个构造方法，只不过
threshold为默认的DEFAULT_LOAD_FACTOR=0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3.3 无参构造函数
只设置负载因子为默认的
DEFAULT_LOAD_FACTOR=0.75，不做任何事情
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
四、resize()
初始化或加倍表大小。如果为空，则根据字段阈值中保持的初始容量目标进行分配。否则，由于我们使用的是2的幂扩展，每个桶中的元素必须保持在同一索引中，或者在新表中以2的幂偏移移动。
resize()的最终结果就是tab扩容为之前的2倍，阈值也变成之前的2倍，但是不能超过最大的容量和最大的阈值。
resize()从大的步骤来看共分为2步：
- 第一步是计算新的容量和阈值
- 第二步是初始化新容量的tab，并将oldCap拷贝到新的tab中
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;
// table已经被初始化过了，所以oldCap > 0
if (oldCap > 0) {
// 已经为最大容量了，不再扩容了
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容为之前的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 阈值也增加为之前的2倍
newThr = oldThr << 1; // double threshold
}
// 以下2种情况均是没有table初始化时，
// 当指定了初始化容量时将会初始化tableSizeFor(initialCapacity)大小的table
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;
// 初始化新容量大小的Tab
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 修改当前HashMap指向newTab
table = newTab;
// 将旧tab的内容拷贝到新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
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 小于oldCap的索引位置不变
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 大于oldCap的索引到先前索引+old的位置
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 因为新的容量为之前容量的2倍，可能会落在先前的位置或者先前+oldCap的位置
// 比如先前容量为4，有hash为2和6两个之前都在2位置，新的容量为8，则先前为
// 2的还是在2，先前为6的则在6了
if (loTail != null) {
loTail.next = null;
// 可能在相同的索引中
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 可能在先前的索引在oldCap上
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
五、put(K key, V value)
先看总结：
- 第一次put时才会初始化tab
- 先put再判断是否需要扩容，如果需要则进行扩容
- 如果put的key在之前已经存在了，modCount不会+1
- 节点有2种类型，链表和红黑树，链表在jdk1.8中采用的是尾插法，当链表的数量达到8时，则会转换成红黑树
- 就算指定了onlyIfAbsent为ture，但是在oldValue为null的情况下，还是会更新value
- value可以为null，不能用get(Object key)是否为null来判断该key是否存在，应该用containsKey(Object key)通过Node是否为null，来判断key是否存在
源代码如下所示：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
直接调用hash(Object key)方法后再调用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;
// 可以看到这里，当tab为null或者容量为0时会调用resize()方法初始化tab
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果对应的索引位置为null，说明没有元素，之间保存即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else { // 发生了hash冲突，需要进行后续处理
Node<K,V> e; K k;
// put的是已经存在的key则将e赋值为p，在后续处理中，当e不为null时尝试更新value
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 {
// 在链表中查找插入的位置
for (int binCount = 0; ; ++binCount) {
// 查找到最后都没有找到对应的key，则在尾部插入新的节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 插入新节点后需要判断是否转化成红黑树TREEIFY_THRESHOLD=8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 找到了就结束
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 对应的key之前已经存在，尝试更新
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 当关闭onlyIfAbsent时或者oldValue为null时更新
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 更新后返回旧的值，结束
return oldValue;
}
}
// 走到这里来，说明有新增的key，tab的结构发生了变化，modCount需要+1
++modCount;
// 增加当前的大小，并且如果大于了阈值，则进行扩容，看到这里，需要认识到是先put在进行扩容的
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
六、get(Object key)
先看总结
- 查询时会先通过hash找到对应索引的节点，在通过比较key是否相同，找到需要查询的节点
- 当有多个hash冲突时，需要在链表或者红黑树中查询，当链表过长时会影响性能，所以会转化成红黑树，在红黑树中进行查找
- 由于用到了红黑树，所以需要排序，当key实现了Comparable接口时直接排序，否则将会使用key的hashCode来进行排序
源代码如下所示：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
依赖于getNode(int hash, Object key)方法：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 找到了对应索引的节点并且key相同，则直接返回
if (first.hash == hash && // always check first node
((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;
}
