HashMap基础
HashMap继承了AbstractMap类，实现了Map，Cloneable，Serializable接口
HashMap的容量，默认是16
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
HashMap的加载因子，默认是0.75
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
当HashMap中元素数超过容量*加载因子时，HashMap会进行扩容。
HashMap实现原理
Node和Node链
首先来了解一下HashMap中的元素类型
HashMap类中的元素是Node类，翻译过来就是节点，是定义在HashMap中的一个内部类，实现了Map.Entry接口。
Node类的定义如下：
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
可以看到，Node类的基本属性有：
hash：key的哈希值
key：节点的key，类型和定义HashMap时的key相同
value：节点的value，类型和定义HashMap时的value相同
next：该节点的下一节点
值得注意的是其中的next属性，记录的是下一个节点本身，也是一个Node节点，这个Node节点也有next属性，记录了下一个节点，于是，只要不断的调用Node.next.next.next……，就可以得到：
Node-->下个Node-->下下个Node……-->null
这样的一个链表结构，而对于一个HashMap来说，只要明确记录每个链表的第一个节点，就能顺序遍历链表上的所有节点。
拉链法
HashMap使用拉链法管理其中的每个节点。
由Node节点组成链表之后，HashMap定义了一个Node数组：
transient Node<K,V>[] table;
这个数组记录了每个链表的第一个节点，于是最终形成了HashMap下面这样的数据结构：
这种数组+链表的数据结构，使得HashMap可以较为高效的管理每一个节点。
关于Node数组 table
对于table的理解，对后面关于扩容的理解很有帮助。
table在第一次往HashMap中put元素的时候初始化。
如果HashMap初始化的时候没有指定容量，那么初始化table的时候会使用默认的DEFAULT_INITIAL_CAPACITY参数，也就是16，作为table初始化时的长度。
如果HashMap初始化的时候指定了容量，HashMap会把这个容量修改为2的倍数，然后创建对应长度的table。比如：指定长度为7，那么则创建长度为8的table。
table在HashMap扩容的时候，长度会翻倍。
所以table的长度肯定是2的倍数。
修改容量的方法是这样的：
/**
* Returns a power of two size for the given target capacity.
*/
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;
}
所以要注意，如果要往HashMap中放1000个元素，又不想让HashMap不停的扩容，最好一开始就把容量设为2048，设为1024不行，因为元素添加到七百多的时候还是会扩容。
散列算法
当调用HashMap.put()方法时，经历了以下步骤：
1，对key进行hash值计算
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2，hash值和table.length取模
取模的方法是(table.length - 1) & hash，算法直接舍弃了二进制hash值在table.length以上的位，因为那些位都代表table.length的2的n次方倍数。
取模的结果就是Node将要放入table的下标。
比如，一个Node的hash值是5，table长度是4，那么取余的结果是1，也就是说，这个Node将被放入table[1]所代表的链表（table[1]本身指向的是链表的第一个节点）。
3，添加元素
如果此时table的对应位置没有任何元素，也就是table[i]=null，那么就直接把Node放入table[i]的位置，并且这个Node的next==null。
如果此时table对应位置是一个Node，说明对应的位置已经保存了一个Node链表，则需要遍历链表，如果发现相同hash值则替换Node节点，如果没有相同hash值，则把新的Node插入链表的末端，作为之前末端Node的next，同时新Node的next==null。
如果此时table对应位置是一个TreeNode，说明链表被转换成了红黑树，则根据hash值向红黑树中添加或替换TreeNode。（JDK1.8）
4，如果添加元素之后，Node链表的节点数超过了8个，则该链表会考虑转为红黑树。（JDK1.8）
5，如果添加元素之后，HashMap总节点数超过了阈值，则HashMap会进行扩容。
相关代码是这样的：
putVal
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果数组为空，获取数组的长度为0，则进行扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) //获取此次放入的key应该放入的位置（（数组长度-1） & hash） ，如果这个位置上没有值，则创建新的Node节点
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//在这里产生了hash碰撞，如果此次位置上的node的hash 值和传入的hash 值相等并且key指向了Java堆中同一个对象，或者key不为空并且key的值相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; //把产出hash碰撞的数组上的node节点赋值给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) { //如果链表中当前节点的下一个节点为空则创建新的Node节点作为此次添加的值
p.next = newNode(hash, key, value, null);
//如果链表长度大于等于8，则进行树化逻辑（在树化逻辑中，还进行了判断此HashMap中数组的长度有没有达到64，如果达到了才进行树化）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果hash 相等，key相等则进行替换value
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) //onlyIfAbsent =false
e.value = value; //把此次添加的value赋值给e.value，就是对key相等的进行覆盖的过程
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //数量加一
if (++size > threshold) //判断数量是否到达阈值，如果大于阈值，则进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
HashMap和红黑树
从JDK1.8开始，在HashMap里面定义了一个常量TREEIFY_THRESHOLD，默认为8。当链表中的节点数量大于TREEIFY_THRESHOLD时，链表将会考虑改为红黑树，代码是在上面putVal()方法的这一部分：
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;
}
其中的treeifyBin()方法就是链表转红黑树的方法，这个方法的代码是这样的：
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
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);
}
}
可以看到，如果table长度小于常量MIN_TREEIFY_CAPACITY时，不会变为红黑树，而是调用resize()方法进行扩容。MIN_TREEIFY_CAPACITY的默认值是64。显然HashMap认为，虽然链表长度超过了8，但是table长度太短，只需要扩容然后重新散列一下就可以。
后面的代码中可以看到，如果table长度已经达到了64，就会开始变为红黑树，else if中的代码把原来的Node节点变成了TreeNode节点，并且进行了红黑树的转换。
关于TreeNode
当HashMap把链表转为红黑树的时候，原来的Node节点就会被转为TreeNode节点，TreeNode也是HashMap中定义的内部类，定义大概是这样的：
/**
* Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
* extends Node) so can be used as extension of either regular or
* linked node.
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
/**
* Ensures that the given root is the first node of its bin.
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
int index = (n - 1) & root.hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
if (root != first) {
Node<K,V> rn;
tab[index] = root;
TreeNode<K,V> rp = root.prev;
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
rp.next = rn;
if (first != null)
first.prev = root;
root.next = first;
root.prev = null;
}
assert checkInvariants(root);
}
}
/**
* Finds the node starting at root p with the given hash and key.
* The kc argument caches comparableClassFor(key) upon first use
* comparing keys.
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
可以看到，TreeNode继承了LinkedHashMap的Entry，TreeNode节点在构造时，也指定了hash值，key，value，下一节点next，这些都是和Node相同的结构。
同时，TreeNode还保存了父节点parent， 左孩子left，右孩子right，上一节点prev，另外还有红黑树用到的red属性。
红黑树基础
红黑树是一种近似平衡的二叉查找树，他并非绝对平衡，但是可以保证任何一个节点的左右子树的高度差不会超过二者中较低的那个的一倍。
红黑树有这样的特点：
1，每个节点要么是红色，要么是黑色。
2，根节点必须是黑色。叶子节点必须是黑色NULL节点。
3，红色节点不能连续。
4，对于每个节点，从该点至叶子节点的任何路径，都含有相同个数的黑色节点。
5，能够以O(log2(N))的时间复杂度进行搜索、插入、删除操作。此外,任何不平衡都
会在3次旋转之内解决。
HashMap扩容机制
当HashMap决定扩容时，会调用HashMap类中的resize(int newCapacity)方法，参数是新的table长度。在JDK1.7和JDK1.8的扩容机制有很大不同。这里指讲述JDK1.8
JDK1.8下的扩容机制
resize()
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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) { //如果oldCap（之前的数组）容量大于0
//如果oldCap（之前的数组）容量大于等于MAXIMUM_CAPACITY（最大容量1 << 30）
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;//把Integer的最大值赋值给threshold（阈值）
return oldTab; //直接返回之前的数组，因为数组容量已到最大值，不再扩容
}
//这里数组进行了扩容，HashMap会扩容至原来的2倍（oldCap << 1 转化为二进制，向左移一位，就相当于乘以2），如果oldCap（数组之前的容量）扩容之后小于MAXIMUM_CAPACITY （最大容量）并且oldCap（数组之前的容量>=数组默认的容量（16））
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//扩容之后，那么阈值也要变大，所有执行如下代码（也就是之前的阈值乘以2）
newThr = oldThr << 1; // double threshold
}
//如果之前的阈值大于0（在创建HashMap的时候，如果指定其容量，比如 Map map1=new HashMap(7); 则在创建对象的时候，会获取大于等于7的并且是2的倍数的值作为数组的容量，并且把这个获取到的容量赋值给threshold）
else if (oldThr > 0) // initial capacity was placed in threshold（初始容量设置为阈值）
newCap = oldThr; //把之前的阈值赋值给新数组的容量
else { // zero initial threshold signifies using defaults（零初始阈值表示使用默认值） 这里就是创建HashMap时，没有指定大小
newCap = DEFAULT_INITIAL_CAPACITY; //把默认初始容量赋值给新数组容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //默认负载因子x默认初始容量
}
if (newThr == 0) { //如果新阈值等于0，这里就是在创建HashMap时指定了大小
float ft = (float)newCap * loadFactor; //指定的大小乘以负载因子
//如果容量小于最大容量并且计算出的阈值小于最大容量，则采用此次计算出的阈值，否则使用Integer.MAX_VALUE作为阈值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //计算出的阈值赋值给threshold
@SuppressWarnings({"rawtypes","unchecked"})
//创建一个以newCap为容量大小的Node数组
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;
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;
}
}
}
}
}
return newTab;
}
