HashMap是使用频率超级高的java容器，其之所以使用频率高是因为它的get和put的效率极其高,可以在o(1+a)的时间内完成get和put操作。
HashMap还有一个兄弟类叫HashTable，他们基本基本提供相同的功能，他们之间的不同主要是HashTable中的方法都采用了同步策略，并且不支持null键，相反，HashMap则不是线程安全的且支持null键null值。
接下来开始一步步分析HashMap的源码。
首先,看下HashMap的继承体系结构.
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
HashMap继承了AbstractMap这个抽象类，并且实现了Map、克隆和序列化接口。
首先看看,存在那些关键的常量
//默认的初始容量，这里有一点注意的是，HashMap的桶的个数都保持在2的幂次，如果16=2^4
//如果确定要存储多个简直时，建议指定容器的初始容量的大小，避免自动扩容造成的性能浪费
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大允许的桶的个数，为Integer.MAX_VALUE / 2 + 1
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的装载因子，这个参数是用来平衡时间和空间上的开销，装载因子越大，空间利用率越高，但是查询效率就越低
//装载因子越小，空间利用率越低，查询效率就越高，0.75f是一个合理的装载因子，一般情况无需改变
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//这是javaJDK1.8新增的阈值，是决定是否将链表树化的关键，如果一个桶中的Node链表的长度超过了8，那么就会将链表转化为红黑树
//因为随着HashMap中存入的数据越来越多，桶中的链会越来越长，那就就会造成查找效率低下，如果桶中的结点多于8个，那么就将链表
//转化为红黑树，这样就能将查找效率提高到o(logN)而不是o(n)
static final int TREEIFY_THRESHOLD = 8;
//如果桶中的数据少于6个，那么就重新将红黑树转换成为链表
static final int UNTREEIFY_THRESHOLD = 6;
//最小的树化的桶数，如果哈希表中桶数<64，那么就进行resize，否则进行树化
//这个值最少应该是4 * treeify threshold，这样就能减少resize和treeify的冲突
static final int MIN_TREEIFY_CAPACITY = 64;现在咱们知道了，新的HashMap由于在底层维护了一个新的数据结构-红黑树，即使在非常大量的数据下也能保持良好的查找速度。接下来看看，看看HashMap底层的节点是如何维护的。可以看出JDK1.8之后将Entry改成了Node,这样更加符合连标和红黑树中元素的语义。两个节点只有当键和值都相等时才是等价的。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
//其他方法省略
}
好吧，说了这么多，用一张网上的图来形象的描述一下HashMap的逻辑数据结构吧。
哈哈哈，是不是感觉很Q很萌。
说了这么多,那么HashMap底层的哈希策略是如何的呢？
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
哈哈，就是这样的,简单吧，虽然看起来很简单，但是里面确实存在很大学问的，核心思想就是通过右移，来使低位尽量不同，来防止那些比较差劲的hashCode()方法造成的节点分布不均匀的情况。
扫描二维码关注公众号，回复：
1562842 查看本文章
有了哈希策略了，除了哈希策略有讲究之外，咱们再看看其底层的Capacity的计算方法。
这个方法通过右移，使得计算出来的结果都是不小于cap的的2的幂次方，不信大家动手计算试试看。至于为什么桶的容量都是2的幂次方呢？
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的桶定位是基于取模的，如果使用2的幂次方的容量，可以用hash&(n-1)这样高效的位运算来代替hash%n。更重要的是,他能更好的使节点均匀的分布在各个桶中，分布的越均匀，查询的效率就会越高。
下面来到了HashMap的构造器。
/** 初始化装载因子和resize的阈值，大家注意了initialCapacity可能不是在这里初始化的 */
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);//初始化扩容阈值
}
/** 使用默认的装载因子 */
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/** 无参构造器 */
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/** 直接通过一个Map来进行初始化 */
public HashMap(java.util.Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);//第二个参数false标示是第一次往HashMap里面添加内容，否则为true
}
前面三个构造器没什么好说的，从第四个构造器说起。
在初始化装载因子以后，就调用了一个putMapEntries()的方法，走进去瞧一瞧看一看。
final void putMapEntries(java.util.Map<? extends K, ? extends V> m, boolean evict/**标示是第一次,first time*/) {
int s = m.size();
if (s > 0) {
/** 如果是第一次传值,你的table必然还没有初始化，那好吧，那就初始化吧 */
if (table == null) {
float ft = ((float)s / loadFactor) + 1.0F;//这里的用意不是很明显，估摸着能够更快的探测是否到最大容量,因为最大容量为Integer.MAX_VALUE / 2 + 1
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)//threshold还没初始化仍然为0值
threshold = tableSizeFor(t);//初始扩容阈值为
}//$到这里为止，初始化了扩容的阈值，table仍然为null，也就是还没有初始化
/** 如果不是第一次添加,并且要添加的内容本身就超过了扩容的阈值，那肯定是要扩容的 */
else if (s > threshold)
resize();
/** 无论你是否已经初始化了table，这里都要开始往HashMap里面添键值对了，这里有一个方法叫putVal，这才是真正的push方法 */
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
此时此刻，真的像洋葱一样，let's进入到putVal()。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
HashMap.Node<K, V>[] tab;
HashMap.Node<K, V> p;
int n, i;
/** 哈哈，如果你的table还没初始化，或者table里面还是空的，憋说话，resize()，resize()返回的是一个更大的table，并且oldTable里面的数据已经放进去了 */
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/** 此时此刻往新的tab里面添加新元素吧，如果桶是空的，那么直接丢进去一个Node */
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
/** 否则，对应的桶里面有元素了，怎么办，往下看...*/
else {
HashMap.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 HashMap.TreeNode)
e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
//否则就只可能是普通的元素，那么就按平常的方法插入元素即可
else {
for (int binCount = 0; ; ++binCount) {
//如果当前节点的next没有了,那么就把节点插到当前节点的的后面
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入节点之后达到了树化的阈值，那么就将整个桶树化
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//如果当前节点hash和键和p的哈希值一样而键也一样，那么就直接退出
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//否则pointer指向下一个链表节点
p = e;
}
}
//否则e找到了匹配到的元素，那么就看看是否要替换旧值，然后替换掉
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//这个modCount的是为了快速检测迭代修改的错误的，也就是在迭代时，你不能删除和添加，否则就抛出ConcurrentModificationException
//看是否需要扩容
if (++size > threshold)
resize();
//这里是为LinkedHashMap写的钩子函数，666
afterNodeInsertion(evict);
//插入成功,返回null
return null;
}
那么说了这么久,再看看究竟是如何扩容的把？
/** 扩容 */
final HashMap.Node<K,V>[] resize() {
HashMap.Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
/** 这里简直高明，默认直接扩容2成2倍 */
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//默认容量在这里设置为16
newCap = DEFAULT_INITIAL_CAPACITY;
//新的扩容阈值为16 * 0.75
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;
@SuppressWarnings({"rawtypes","unchecked"})
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
//在这里终于初始化了table,真是用心良苦啊，接下来新的table和久的table是一个引用了
table = newTab;
//新的table生成之后,将旧的table里面的元素装进新的table里面，也就是重新哈希，这里原来在一个桶中的元素会被分开，如果原来一个桶
//的元素哈希之后还在一个桶，那么我们说这次重哈希是没有意义的。
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
HashMap.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 HashMap.TreeNode)
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.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;//返回新table的引用,同时他也是HashMap的table引用
}
从这里来说，我们已经讲完了基本的初始化和put操作是如何进行的。接下来看看树化是个什么样的过程。
final void treeifyBin(HashMap.Node<K,V>[] tab, int hash) {
int n, index;
HashMap.Node<K,V> e;
/** 如果桶的个数还不超过64，那么就不会树化，还会继续扩容充哈希 */
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
/** 树化其实就是把所有的连标节点封装成为TreeNode然后将,然后使封装的TreeNode形成一棵二叉树 */
else if ((e = tab[index = (n - 1) & hash]) != null) {
HashMap.TreeNode<K,V> hd = null, tl = null;
do {
HashMap.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);
/** 如果二叉树的跟节点不是null的,那么就开始红黑树化，这里才是真正的树化，前面形成的一直是简单的二叉搜索树 */
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
讲完了put方法,下面看下get方法。
public V get(Object key) {
HashMap.Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
继续走进getNode。
final HashMap.Node<K,V> getNode(int hash, Object key) {
HashMap.Node<K,V>[] tab;
HashMap.Node<K,V> first, e;
int n;
K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
/** 总是和第一个节点进行比较，如果第一个节点就和要查询的节点匹配，那么就将第一个绩点返回 */
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 HashMap.TreeNode)
return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
/** 否则就遍历链表 */
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e; //get and return
} while ((e = e.next) != null);
}
}
return null; //referring not found
}这里为止，我们了解到了JDK1.8对HashMap的一些优化。哈哈，这是我的第二篇博客啦。