HashMap设置的常量
/**
* 初始化容量大小，必须是2的N次方数 1<< 4 = 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* HashMap容量的上限，必须小于等于2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 当构造函数没有指定加载因子时，默认的加载因子是0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 链表转成红黑树的阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 红黑树转成链表的阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 当HashMap的数组大小小于64时，采用扩容的方式避免冲突；
* 当大于64时，转成树来避免冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap的数组
HashMap的底层是用一个Node数组实现的。Node定义了四个属性，哈希码hash，键key，值value，指向的下一个节点next。Node的next属性表示这是一个单链表的结构，具有相同hash值的元素会存放在table数组的同一个坐标位置中，然后以单链表的形式进行关联。
transient Node<K,V>[] table;
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
HashMap的构造函数
/**
* initialCapacity 初始数组大小，大小在0和MAXIMUM_CAPACITY(包括)之间。
* loadFactor 加载因子 如果值小于等于0，或者不是float类型，抛出IllegalArgumentException。
*/
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);
}
/**
* 容量必须是2的幂，通过此方法计算得到大于给定容量的最小的2的幂
*/
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* 该方法的作用是返回无符号整型i的最高非零位前面的0的个数，包括符号位在内；
*/
public static int numberOfLeadingZeros(int i) {
// HD, Count leading 0's
if (i <= 0)
return i == 0 ? 32 : 0;
int n = 31;
if (i >= 1 << 16) {
n -= 16; i >>>= 16; }
if (i >= 1 << 8) {
n -= 8; i >>>= 8; }
if (i >= 1 << 4) {
n -= 4; i >>>= 4; }
if (i >= 1 << 2) {
n -= 2; i >>>= 2; }
return n - (i >>> 1);
}
假设cap = 16, 转成二进制就是 0001 1111
cap - 1 = 15, 转成二进制就是 0000 1111
代入numberOfLeadingZeros()方法计算：1的二进制表示是 0000 0001
i = 15, 1 << 16 即是2的16次方 转成二进制是 1 00000000 0000000 ，i < (1 << 16)
i = 15, 1 << 8 即是2的8次方 转成二进制是 1 00000000， i < (1 << 8)
i = 15, 1 << 4 即是2的4次方 转成二进制是 0001 0000， i < (1 << 4)
i = 15, 1 << 2 即是2的2次方 转成二进制是 0000 0100, i > (1 << 2), n = 31 - 2 = 29 , i >>> 2 转成二进制 0000 0011 也就是 3
return n - ( i >>> 1 ) = 29 - (i >>> 1 二进制是 0000 0001 , 十进制是1) = 28
注意：这里为什么是i >>>= 16; i >>>= 8; i >>>= 4; i >>>= 2; i >>> 1 ？
16 + 8 + 4 + 2 + 1 = 31 int 是 4个字节 也就是32位。
在计算机中，负数以其正值的补码形式表达。
原码：一个整数，按照绝对值大小转换成的二进制数，称为原码。
反码：将二进制数按位取反，所得的新二进制数称为原二进制数的反码。取反操作指：原为1，得0；原为0，得1。（1变0; 0变1）
补码：反码加1称为补码。
-1 的二进制表示 是 11111111 11111111 11111111 11111111 右移28位就是 0000 1111 转成十进制是 15
tableSizeFor(15)拿到的n = 15 0 < 15 < MAXIMUM_CAPACITY，最后返回的结果是n + 1 = 16
计算Hash
计算key的hash值，如果key等于null，hash值是0，也就是会将key等于null的这个元素放在数组的第一个位置上。否则根据key的hashcode值与key的hashcode值右移16位后进行异或得到最后的hash。这也说明HashMap是允许key为null的。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
计算元素存放数组的位置
元素存放在数组的位置需要满足两个条件：
(1)平均分布在数组的槽
(2)下标区间在(0, 数组长度-1)
HashMap的式通过Node节点的hash值和(数组长度-1)得到的值进行与运算算出添加的元素落在数组的哪一个bucket。与运算的特点是都为1时才为1，所以Node节点的hash值与(数组长度-1)的二进制值进行相与，最后的结果一定是在(0, 数组长度-1)之间的。这种与运算就等同于使用表长度对hash值取模，是散列更均匀。
比如：数组长度是16，那数组的下标区间在[0,15]之间，15的二进制表示是0000 1111。任何一个二进制数与0000 1111做与运算，最后都不会大于0000 1111。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
扩容数组
数组扩容之后，旧数组的元素要迁移到新的数组。一个元素在长度为n的旧数组的下标是i，数组扩容后，新的数组的长度是2n，而该元素在新数组的长度可能是i或者是i + n。
假设 旧数组长度是16，一个元素的hash值是 1111 1111, 数组扩容后大小是32，
与（旧数组长度-1）的二进制 0000 1111 进行与运算后结果是：0000 1111，在旧数组下标是15。
与（新数组长度-1）的二进制 0001 1111(与旧数组相比，往上高位多一个1) 进行与运算后结果是：0001 1111，在新数组下标是31。
如果这个元素的hash值是0000 1111，那这个元素旧数组和新数组的下标都是15。所以元素迁移到新数组后坐标要么保持不变(低位)，要么是原来的坐标加上旧数组长度(高位)。
HashMap的resize()方法是判断元素的hash值与旧数组的长度与运算结果是否等于0（主要目的是判断元素的hash值在扩容后多出的那一个高位上是0），如果等于0，表示留在低位，否则去到高位，。
假设旧数组长度是16，一个元素的hash值是 1111 1111，1111 1111 & 0001 0000 != 0 所以 新的坐标是 15 + 16 = 31;
一个元素的hash值是0000 0111，0000 0111 & 0001 0000 = 0 所以迁移新数组后坐标保持不变。
final Node<K,V>[] resize() {
//oldTab表示扩容前的数组
Node<K,V>[] oldTab = table;
//获取扩容前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//获取扩容前数组的阈值
int oldThr = threshold;
//newCap表示扩容后的数组长度，newThr表示扩容后阈值
int newCap, newThr = 0;
//判断扩容前数组的长度是否大于0
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//如果扩容前数组的长度大于等于容量上限(2的30次方)，将阈值设置为整型的最大值，不再扩容数组，直接返回。
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果扩容前数组长度扩大一倍后小于容量上限，并且扩容前数组的长度大于等于初始容量大小(16),
//将扩容后的阈值设置为扩容前的阈值的2倍（扩容前的阈值的二进制数向左移动一位，即是增大一倍）
newThr = oldThr << 1;
}
else if (oldThr > 0)
//如果扩容前的阈值大于0，扩容后数组的长度等于扩容前的阈值
newCap = oldThr;
else {
// zero initial threshold signifies using defaults
//如果扩容前的数组的长度为0和阈值也为0，说明还没有初始化过。
//将初始化后的数组长度设置为初始容量(16),初始化后的阈值=默认加载因子0.75 * 初始容量16
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);
}
//将HashMap全局的阈值变量设置为当前扩容后的阈值
threshold = newThr;
@SuppressWarnings({
"rawtypes","unchecked"})
//创建扩容后的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将HashMap全局的数组设置为扩容后的数组，当前是空数组，还没有迁移元素。
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)
//e.hash & (newCap - 1) 计算得到新数组的下标位置，然后进行赋值
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果当前节点是一个树节点
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
// preserve order
//loHead表示留在低位的元素的头结点,loTail表示留在低位的元素的尾结点
Node<K,V> loHead = null, loTail = null;
//hiHead表示去到高位的元素的头结点，hiTail表示去到高位的元素的尾结点
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);
//迁移到新数组的坐标j
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//迁移到新数组的坐标j + 旧数组长度
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
添加元素
往HashMap集合里面添加元素也就是往Node数组里面添加元素，添加元素时会先计算key值的哈希码。
使用put()方法，如果HashMap存在相同的key值，返回旧的值，否则返回null。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
在往数组里面添加元素之前，会先判断数组的大小，如果数组为null，或者数组的大小为0，先要调用resize()方法是做一个数组初始化(默认容量是16，阈值=加载因子0.75 * 默认容量16)。
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)
//数组初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//如果坐标i上没有元素，直接添加元素
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果i坐标上的元素的hash值和key值与当前插入的元素一致
e = p;
else if (p instanceof TreeNode)
//如果是树节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//遍历链表
for (int binCount = 0; ; ++binCount) {
//如果p.next为null，表示已经到达链表尾部
if ((e = p.next) == null) {
//尾插法，添加新的节点
p.next = newNode(hash, key, value, null);
//如果链表数量大于TREEIFY_THRESHOLD，转成树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如何e结点与待插入节点的key和hash一致，直接跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e结点是和待插入节点key和hashcode相同的结点。
if (e != null) {
V oldValue = e.value;
//onlyIfAbsent表示只有不存在才能插入
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 节点被访问的回调函数
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//插入的元素的数量是否大于阈值
if (++size > threshold)
//重新扩容
resize();
afterNodeInsertion(evict);
return null;
}
#HashMap.modCount
先来看下HashMap对modCount的定义：
/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient int modCount;
modCount是用来标记HashMap被结构修改的次数。结构性修改是更改HashMap中的映射数或以其他方式修改其内部结构（例如rehash）的结构修改。 此字段用于使HashMap的Collection-view上的迭代器快速失败。
HashMap<String, String> result = new HashMap<String, String>();
result.put("a","1");
result.put("b", "2");
Iterator<Map.Entry<String, String>> iterator = result.entrySet().iterator();
while(iterator.hasNext()) {
Map.Entry<String, String> map = iterator.next();
if("a".equalsIgnoreCase(map.getKey())) {
// iterator.remove();
result.remove(map.getKey());
}
}
往HashMap集合里添加了2次元素之后，modCount等于2，这时候调用HashIterator，会把modCount的值赋给expectedModCount。再调用HashMap的remove()方法，modCount的值变成3，然而调用EntryIterator的next()方法，会调用父类HashIterator的nextNode()方法。nextNode方法判断modCount与expectedModCount的值是否相等，不相等抛出java.util.ConcurrentModificationException。正确应该使用Iterator的remove()方法，Iterator的remove()方法会将modCount值从新赋给expectedModCount。
多个线程同时操作一个HashMap也有可能出现java.util.ConcurrentModificationException。
public Set<Map.Entry<K,V>> entrySet() {
//这里的es获取到的是HashMap$EntrySet
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public final Iterator<Map.Entry<K,V>> iterator() {
//实例化EntryIterator
return new EntryIterator();
}
}
//EntryIterator继承HashIterator，在调用EntryIterator构造函数之前会先调用父类构造函数
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() {
return nextNode(); }
}
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
//这里将modCount赋值给expectedModCount
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) {
// advance to first entry
do {
} while (index < t.length && (next = t[index++]) == null);
}
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {
} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
//删除之前先校验modeCount值是否有被修改过
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
//删除节点后,modCount值发生变化
removeNode(p.hash, p.key, null, false, false);
//重新将modCount值赋给expectedModCount
expectedModCount = modCount;
}
}