前言：
先上Java集合框架框图，以对其整体把握
概述
本文将解析HashMap的工作原理，put()和get()方法的过程是如何实现的，equals()和hashCode()的都有什么作用，HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？即HashMap是如何扩容的？
先看下面程序的基本操作：
Map map = new HashMap<String,Integer>();
map.put("A",90);
map.put("B",91);
map.put("C",92);
map.put("D",92);
map.put("数学",90);
map.put("化学",87);
Set<Map.Entry> set = map.entrySet();
for(Map.Entry e: set){
System.out.println("name:" + e.getKey() + " " +"grade:" + e.getValue());
}运行结果：
name:A grade:90
name:B grade:91
name:C grade:92
name:D grade:92
name:数学 grade:90
name:化学 grade:87下图即表示上面的数据的存储结构，这样先对Hashmap 有一个基本认识。
HashMap源码分析：
Hashmap的核心成员变量：
//HashMap的哈希桶数组，非常重要的存储结构，用于存放表示键值对数据的Node元素。
transient Node<K,V>[] table;
//HashMap将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set<Map.Entry<K,V>> entrySet;
//HashMap中实际存在的Node数量，注意这个数量不等于table的长度，甚至可能大于它，因为在table的每个节点上是一个链表（或RBT）结构，可能不止有一个Node元素存在。
transient int size;
//HashMap的数据被修改的次数，这个变量用于迭代过程中的Fail-Fast机制，其存在的意义在于保证发生了线程安全问题时，能及时的发现（操作前备份的count和当前modCount不相等）并抛出异常终止操作。
transient int modCount;
//HashMap的扩容阈值，在HashMap中存储的Node键值对超过这个数量时，自动扩容容量为原来的二倍。
int threshold;
//HashMap的负载因子，可计算出当前table长度下的扩容阈值：threshold = loadFactor * table.length。
final float loadFactor; 在HashMap实现了一个内部类Node
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;
}
}HashMap 的核心常量:
//默认的初始容量为16，必须是2的幂次
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量即2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当put一个元素时，其链表长度达到8时将链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
//链表长度小于6时，解散红黑树
static final int UNTREEIFY_THRESHOLD = 6;
//默认的最小的扩容量64，为避免重新扩容冲突，至少为4 * TREEIFY_THRESHOLD=32，即默认初始容量的2倍
static final int MIN_TREEIFY_CAPACITY = 64;1、put()过程解析
//put()函数
public V put(K key, V value) {
//调用putVal()函数
//并计算key的哈希值
return putVal(hash(key), key, value, false, true);
}static final int hash(Object key) {
int h;
//计算key的哈希值，在这里将hashCode()计算结果的
//高位与低位做异或运算以后，作为哈希值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}这里通过key.hashCode()计算出key的哈希值，然后将哈希值h右移16位，再与原来的h做异或^运算——这一步是高位运算。这样才能保证hash值所有位的数值特征都保存下来而没有遗漏，从而使映射结果尽可能的松散。最后，根据 n-1 做与操作的取模运算（即n的余数），便得到了table数组的索引。
//这里onlyIfAbsent表示只有在该key对应原来的value为null的时候才插入，
// 也就是说如果value之前存在了，就不会被新put的元素覆盖。
//evict参数用于LinkedHashMap中的尾部操作，这里没有实际意义。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //定义变量tab是将要操作的Node数组引用，
Node<K,V> p; //p表示tab上的某Node节点，
int n, i;//n为tab的长度，i为tab的下标。
//判断当table为null或者tab的长度为0时，
//即table尚未初始化，此时通过resize()方法得到初始化的table
//这种情况是可能发生的，HashMap的注释中提到：
//The table, initialized on first use, and resized as necessary。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//此处通过（n - 1） & hash 计算出的值作为tab的下标i，
//并另p表示tab[i]，也就是该链表第一个节点的位置。并判断p是否为null。
//当p为null时，表明tab[i]上没有任何元素，那么接下来就new
//第一个Node节点，调用newNode方法返回新节点赋值给tab[i]。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//下面进入p不为null的情况，有三种情况：
//第一种：p为链表节点；
//第二种：p为红黑树节点；
//第三种：p是链表节点但长度为临界长度TREEIFY_THRESHOLD，再插入任何元素就要变成红黑树了。
else {
Node<K,V> e;//定义e引用即将插入的Node节点，并且下文可以看出 k = p.key。
K k;
//HashMap中判断key相同的条件是key的hash相同，并且符合equals方法。
//这里判断了p.key是否和插入的key相等，如果相等，则将p的引用赋给e。
//这一步的判断其实是属于一种特殊情况，即HashMap中已经存在了key，
//于是插入操作就不需要了，只要把原来的value覆盖就可以了。
//这里为什么要把p赋值给e，而不是直接覆盖原值呢？答案很简单，
//现如果第一个节点就是就跟要插入的节点相同，赋值给e
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//现在开始了第一种情况，p是红黑树节点，那么肯定插入后仍然是红黑树节点，
//所以我们直接强制转型p后调用TreeNode.putTreeVal方法，返回的引用赋给e
//你可能好奇，这里怎么不遍历tree看看有没有key相同的节点呢？其实，
// putTreeVal内部进行了遍历，存在相同hash时返回被覆盖的TreeNode，否则返回null。
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//接下里就是p为链表节点的情形，也就是上述说的另外两类情况：
//插入后还是链表/插入后转红黑树。另外，上行转型代码也说明了TreeNode是Node的一个子类。
else {
//我们需要一个计数器来计算当前链表的元素个数，并遍历链表，
//binCount就是这个计数器。
for (int binCount = 0; ; ++binCount) {
//遍历过程中当发现p.next为null时，说明链表到头了，
//直接在p的后面插入新的链表节点，即把新节点的引用赋给p.next，
//插入操作就完成了。注意此时e赋给p。
if ((e = p.next) == null) {
//最后一个参数为新节点的next，这里传入null，
// 保证了新节点继续为该链表的末端。
p.next = newNode(hash, key, value, null);
////插入成功后，要判断是否需要转换为红黑树，
// 因为插入后链表长度加1，而binCount并不包含新节点，
// 所以判断时要将临界阈值减1。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//当链表长度大于8时，调用treeifyBin方法，将该链表转换为红黑树。
treeifyBin(tab, hash);
//当然如果不满足转换条件，那么插入数据后结构也无需变动，
// 所有插入操作也到此结束了，break退出即可。
break;
}
//在遍历链表的过程中，我之前提到了，有可能遍历到与插入的key相同的节点，
//此时只要将这个节点引用赋值给e，最后通过e去把新的value覆盖掉就可以了。
//老样子判断key的哈希值并且满足equals()方法
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//找到了相同key的节点，那么插入操作也不需要了，直接break退出循环进行最后的value覆盖操作。
break;
//前面提到过，e是当前遍历的节点p的下一个节点，
// p = e 就是依次遍历链表的核心语句。每次循环时p都是下一个node节点。
p = e;
}
}
//左边注释为jdk自带注释，说的很明白了，针对已经存在key的情况做处理。
if (e != null) { // existing mapping for key
V oldValue = e.value;//定义oldValue，即原存在的节点e的value值。
//前面提到，onlyIfAbsent表示存在key相同时不做覆盖处理，
//这里作为判断条件，可以看出当onlyIfAbsent为false或者oldValue为null时，进行覆盖操作
if (!onlyIfAbsent || oldValue == null)。
e.value = value;//覆盖操作，将原节点e上的value设置为插入的新value。
//这个函数在hashmap中没有任何操作，是个空函数，他存在主要是为了
//linkedHashMap里面的一些后续处理工作。
afterNodeAccess(e);
//这里很有意思，他返回的是被覆盖的oldValue。我们在使用put方法时很少用他的返回值
//，甚至忘了它的存在，这里我们知道，他返回的是被覆盖的oldValue。
return oldValue;
}
}
//收尾工作，值得一提的是，对key相同而覆盖oldValue的情况，在前面已经return，
//不会执行这里，所以那一类情况不算数据结构变化，并不改变modCount值。
++modCount;
//同理，覆盖oldValue时显然没有新元素添加，除此之外都新增了一个元素，
//这里++size并与threshold判断是否达到了扩容标准。
if (++size > threshold)
resize(); //当HashMap中存在的node节点大于threshold时，hashmap进行扩容。
//这里与前面的afterNodeAccess同理，是用于linkedHashMap的尾部操作，HashMap中并无实际意义。1
afterNodeInsertion(evict);
return null;//最终，对于真正进行插入元素的情况，put函数一律返回null。
}在putVal()中有resize()函数，也就是HashMap的扩容机制，扩容后大小为原来的2倍，这也是table容量为什么是2的指数次幂的原因。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // oldTable:当前的表
int oldCap = (oldTab == null) ? 0 : oldTab.length; //如果你是新创建的话 表的大小就是0 否则就是原来的大小
//第一次是为0的 代表 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
int oldThr = threshold;
int newCap, newThr = 0; //新的容量和新的扩容
//如果旧的容量大于0
if (oldCap > 0) {
//如果旧的容量大于最大的容量
if (oldCap >= MAXIMUM_CAPACITY) {
//那么扩容大小 = 最大范围
threshold = Integer.MAX_VALUE;
//直接返回了
return oldTab;
}
//否则 如果新的大小等于 oldCap * 2 < 最大的容量 ， 并且旧的容量大于默认的初始化大小16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// double threshold 新的扩容 = 旧的扩容 * 2
newThr = oldThr << 1;
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr; //如果旧的扩容本来就大于0，那么新的容量就是旧的扩容
else { // zero initial threshold signifies using defaults 说明是 threshold为0的时候的情况
newCap = DEFAULT_INITIAL_CAPACITY; //新的容量为默认容器的容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //新的阙值为 默认的容量 * 负载因子
}
if (newThr == 0) { //如果新的扩容为0
float ft = (float)newCap * loadFactor; //计算得到新的阙值
//新的阙值 = 如果新的容量小于 最大的容量 并且 新的阙只 < 最大的容量 那么新的阙值 = 计算的 否则 = 最大int
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //阙值 = 新的阙值
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建一个新的哈希数组桶 大小为新的容量
table = newTab; //
if (oldTab != null) {
//遍历旧的hash桶
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//如果旧的hash桶的元素不为null e为旧的hash桶的元素
oldTab[j] = null; //旧的hash桶设置为null
if (e.next == null) //如果你就是一个元素
newTab[e.hash & (newCap - 1)] = e; //那么在新的hash桶给你安排一个位置 位置是你的hash值 & 新的桶的容量-1 这相当于 你的hash值 与 你的容量进行取模运算
else if (e instanceof TreeNode) //如果你不只一个元素并且是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;
}