介绍
HashMap在JDK1.8中和之前版本相比发生了很大的而变化。最主要的是将底层结构由数组+链表改成了数组+链表/红黑树的形式。虽然在一定程度上加大了复杂度，但却加大了效率。即使一个桶中数据很多也能保证logn的操作时间复杂度。
构造方法
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);
}
这个构造方法是传入初始大小和加载因子的方法。（也可以不写参数，此时将使用默认值 默认大小16 默认加载因子0.75）
其中加载因子是大于0的float。而数组大小为大于等于0的int数。注意传入的数组大小并不是最终的大小。请看下面这个方法
static final int tableSizeFor(int cap) {
int n = cap - 1;
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;
}
这个方法将把传入的数组大小参数，转变为一个大于等于参数的2的幂次数。（例如传入31 最终数组大小将是32）最大为MAXIMUM_CAPACITY即2的30次方。最小为1；
需要注意的是此时HashMap的数组并没有初始化。
put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
首先就是调用了hash方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
首先利用key的hashcode（）方法获得哈希值（如果key为null 哈希值为0）然后右移16位然后与原来的哈希值亦或操作。这样的目的是让高位也能参与运算，让哈希值更散列。
put方法中调用了putVal(hash(key), key, value, false, true);方法
这个方法中第三个参数是onlyIfAbsent当它为true时如果传入的key相同将不进行替换value。（如果调用put方法的话，它默认是false 如果调用putIfAbsent方法它的值默认为true）
第四个参数evict在这里默认为false（这个参数只有在putAll方法中默认为true），这个参数的意思是如果为false则表明当前是创建模式（不懂）。用到这个参数的地方是这个方法
afterNodeInsertion(evict);但是这是个空方法，JDK1.8的HashMap并没有实现这个方法。
接下来看一下put的具体逻辑
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)
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))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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;
}
}
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;
}
接下来我们一点一点的分析
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
这段d的意思是初始化的逻辑，table==null或者 lenght ==0，这是第一次添加元素的时候。也就是说hashMap实际上第一次添加元素才进行初始化。
我们进入resize方法看一下，初始化具体的内容
newCap = DEFAULT_INITIAL_CAPACITY;//数组大小
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阈值
threshold = newThr;
@SuppressWarnings({
"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
return newTab;
这块没什么好说的。就是申请了Node数组（相当于HashMap（1.7）中的 entry 里面的属性有 hash key value next）
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
然后再回到put的操作中来
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
这句的意思是，如果要插入的地方没有发生碰撞就直接放到那就好了。注意：JDK1.7中如果没发生碰撞是不会发生扩容的，但是即使没有发生碰撞1.8也会扩容。（前提是正在插入第 大于阈值个元素）
p = tab[i = (n - 1) & hash]这里还顺便计算了下index的值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
他先判断了一下第一个节点的key和要插入的key冲不冲突。如果冲突了就赋值给e
下面几行代码就是判断这个节点是不是红黑树的节点，要如果是红黑树的话，就调用红黑树的方法插入元素
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
红黑树插入时具体怎么旋转怎么调整的就不细说了，感兴趣的可以去看看红黑树的形式。
不过有一点要提一下，就是链表在转成红黑树的时候会生成一个双向链表，当添加新元素的时候，这个新元素不仅要添加到红黑树中，同时也要在这个双向链表中记录一下，这个新元素插入双向链表的位置就是它父节点的下一个。
下面的代码是向链表中插入元素
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
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是不是已经存在，如果存在就和上面一样赋值给e（当break的时候e就是重复节点）
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
上面部分代码
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
p.next = newNode(hash, key, value, null);就是向链表中插入新节点（jdk1.8是尾插法，1.7是头插法 因为在并发时如果发生扩容头插法可能产生循环链表）。
下面这句代码就是判断进入链表转红黑树代码的逻辑，其中TREEIFY_THRESHOLD就是变成红黑树的阈值 为8.即当有9个元素发生碰撞时就可能会转成红黑树。没错 满足这一个条件并不一定会转成红黑树。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
treeifyBin方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
从这个代码中可以看出，转红黑树的条件还有一个，那就是hashMap数组长度要大于等于64.如果小于64的话，那么就会进行扩容，而不会进行转二叉树。（从这里可以看出，即使没有达到扩容阈值也有可能发生扩容）
那么它是怎么转红黑树的呢
首先先把原来的Node转换成红黑树的TreeNode节点。然后把原来的链表改成一个双向链表
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
转成双向链表后就进入treeify(Node<K,V>[] tab)方法，把节点插入红黑树中。插入完成后把红黑树的根节点改成双向链表的首节点
如果在插入时发现key已经相同（已经把重复节点赋值给e）
这里就是用到了onlyIfAbsent参数，判断是否把原来的value覆盖
if (e != null) {
// existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
添加完元素后也会判断下是否超过阈值，超过了就扩容（如果阈值时12 则在插入第13个元素的时候才会扩容）
++modCount;
if (++size > threshold)
resize();
接下来看一下扩容的逻辑
扩容就是resize方法（初始化也是这个方法）
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
}
很明显扩容是 数组大小翻倍 阈值也翻倍
具体的扩容逻辑如下
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;
}
}
}
}
}
先说链表扩容后怎么移动
首先他的扩容方式和1.7不太相同。因为扩容后他的下标只可能在两个位置，一个是原下标，另一个是原下表+原数组大小的位置。因此，扩容是用两个指针先把将要移到这两个位置的节点先串起来，然后再一起移动。
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 {
// 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;
}
}
}
}
}
接下里说红黑树扩容后怎么移动
红黑树遍历之前转红黑树时创建的双向链表，判断节点应该放到那两个位置中的哪一个（原数组下标和元素组下标+原数组大小），双向链表也要维护成各自的双向链表。同时记录每个双向链表中的元素（判断是否需要转成链表）。如果小于等于阈值（6）就转成链表。否则就插入红黑树。
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
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;
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
remove
remove方法中就说一个比较重要的点。红黑树什么时候转成链表。
首先看一下remove红黑树节点时调用的方法
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable)
有一个参数叫movable，这个参数在下面这里用到
if (root == null
|| (movable
&& (root.right == null
|| (rl = root.left) == null
|| rl.left == null))) {
tab[index] = first.untreeify(map); // too small
return;
}
首先先不管其他条件。只有当movable为true时，他才有可能会退化成链表。（这个movable默认为true，只有当用迭代器删除元素的时候为false）。注意这里并不是说小于阈值6就一定会退化（即使movable为true）。