前言
HashMap是Java最常用的集合之一，现今HashMap、Hashtable、ConcurrentHashMap三大集合已经成为面试常考的考点。这三个集合都是以key-value的键值对形式存储元素。除了三者之间的区别和联系。我们更要弄懂每个集合的存储方式、扩容机制、和并发处理。在Java中的源码是非常多的，两三千行代码不可能都记住，所以我们要深刻理解源代码，尽量不要死记硬背。1.8版本的HashMap实现了java.util.function包下的接口，是为新特性提供支持。此外1.8版本的另一个新特性就是HashMap的红黑树。下面直接我们来一起学习HashMap
*概述
* HashMap是常用的Java集合之一，是基于哈希表的Map接口的实现。与HashTable主要区别为不支持同步和允许null作为key和value。
* HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。
* 如果需要满足线程安全，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap。
* 在JDK1.6中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。
* 但是当位于一个数组中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。
* 而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值8时，将链表转换为红黑树，这样大大减少了查找时间。
* 原本Map.Entry接口的实现类Entry改名为了Node。转化为红黑树时改用另一种实现TreeNode
1.8版本HashMap的重要属性
| static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; |
默认的初始容量（容量为HashMap中槽的数目）是16，且实际容量必须是2的整数次幂。 |
| static final int MAXIMUM_CAPACITY = 1 << 30; |
最大容量（必须是2的幂且小于2的30次方，传入容量过大将被这个值替换） |
| static final float DEFAULT_LOAD_FACTOR = 0.75f; |
默认装填因子0.75，如果当前键值对个数 >= HashMap最大容量*装填因子，进行rehash操作 |
| static final int TREEIFY_THRESHOLD = 8; |
JDK1.8 新加，Entry链表最大长度，当桶中节点数目大于该长度时，将链表转成红黑树存储； |
| static final int UNTREEIFY_THRESHOLD = 6; |
JDK1.8 新加，当桶中节点数小于该长度，将红黑树转为链表存储； |
| static final int MIN_TREEIFY_CAPACITY = 64; |
桶可能被转化为树形结构的最小容量。当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突。应该至少4*TREEIFY_THRESHOLD来避免扩容和树形结构化之间的冲突。 |
| transient Node<K, V>[] table;
|
哈希桶数组，分配的时候，table的长度总是2的幂 |
| transient Set<Map.Entry<K, V>> entrySet; |
HashMap将数据转换成set的另一种存储形式，这个变量主要用于迭代功能 |
| transient int size; |
实际存储的数量，则HashMap的size()方法，实际返回的就是这个值，isEmpty()也是判断该值是否为0 |
| transient int modCount; |
hashmap结构被改变的次数，fail-fast机制 |
| int threshold; |
HashMap的扩容阈值，在HashMap中存储的Node键值对超过这个数量时，自动扩容容量为原来的二倍 |
| final float loadFactor; |
HashMap的负加载因子，可计算出当前table长度下的扩容阈值：threshold = loadFactor * table.length |
1.8版本HashMap重要的方法
可以从上面的属性看出来HashMap的构建、扩容还有转化是一件相当麻烦的事情了，下面我们就从构造函数开始深入源码吧。
/**
* 使用指定的初始化容量initial capacity 和加载因子load factor构造一个空HashMap
*
* @param initialCapacity 初始化容量
* @param loadFactor 加载因子
* @throws 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);
}这段构造函数代码的作用就是构建一个合法的HashMap,它验证初始容量的大小和加载因子的范围。其中tableSizeFor是HashMap的一个方法。
/**
* 结果为>=cap的最小2的自然数幂
*/
static final int tableSizeFor(int cap) {
//先移位再或运算，最终保证返回值是2的整数幂
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;
}这个算法真的是高科技，有兴趣的同学可以去看一看大神的分析(点击查看链接，反正他说的我是看懂了)，其他的构造函数就不分析了，粘过来只是浪费版面。还有一个重要的方法hash()计算key的哈希值，上面链接中大神已经讲的很详细了，我也不多哔哔了。现在假设我们已经创建了一个加载因子为0.75，初始容量为16的HashMap，下面我们要开始填入key-value。（一直填入直到zha）
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}可以看到HashMap直接调用了另一个内部函数。并将key值进行高16位和低16位异或操作。（h >>> 16，表示无符号右移16位，高位补0，任何数跟0异或都是其本身，因此key的hash值高16位不变。）。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
} /**
* putVal方法可以分为下面的几个步骤:
* 1.如果哈希表为空，调用resize()创建一个哈希表。
* 2.如果指定参数hash在表中没有对应的桶，即为没有碰撞，直接将键值对插入到哈希表中即可。
* 3.如果有碰撞，遍历桶，找到key映射的节点
* 3.1桶中的第一个节点就匹配了，将桶中的第一个节点记录起来。
* 3.2如果桶中的第一个节点没有匹配，且桶中结构为红黑树，则调用红黑树对应的方法插入键值对。
* 3.3如果不是红黑树，那么就肯定是链表。遍历链表，如果找到了key映射的节点，就记录这个节点，退出循环。如果没有找到，在链表尾部插入节点。插入后，如果链的长度大于TREEIFY_THRESHOLD这个临界值，则使用treeifyBin方法把链表转为红黑树。
* 4.如果找到了key映射的节点，且节点不为null
* 4.1记录节点的vlaue。
* 4.2如果参数onlyIfAbsent为false，或者oldValue为null，替换value，否则不替换。
* 4.3返回记录下来的节点的value。
* 5.如果没有找到key映射的节点（2、3步中讲了，这种情况会插入到hashMap中），插入节点后size会加1，这时要检查size是否大于临界值threshold，如果大于会使用resize方法进行扩容。
*
* @param hash 高16为异或低16位操作后的hash值
* @param key 参数key值
* @param value 参数value值
* @param onlyIfAbsent 如果为true，即使指定参数key在map中已经存在，也不会替换value
* @param evict 如果为false，数组table在创建模式中
* @return 如果value被替换，则返回旧的value，否则返回null。当然，可能key对应的value就是null。
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果哈希表为空，调用resize()创建一个哈希表，并用变量n记录哈希表长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果指定参数hash在表中没有对应的桶，即为没有冲突
// (n-1) & hash计算key在table数组中的下标
if ((p = tab[i = (n - 1) & hash]) == null)
// 直接插入新的Node
tab[i] = newNode(hash, key, value, null);
// 此时p就是当前桶的第一个元素
else {
Node<K,V> e; K k;
// 比较第一个结点的hash与该hash值是否相同
// 并且第一个元素的key值与之相等或者key值不为空
// 并且key的哈希值等于第一结点的哈希值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 将第一个元素赋值给e，用e来记录
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;
}
// 链表节点的<key, value>与put操作<key, value>相同时，不做重复操作，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 找到或新建一个key和hashCode与插入元素相等的键值对，进行put操作
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent为false或旧值为null时，允许替换旧值，否则无需替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//访问后回调
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
//更改结构化信息
++modCount;
// 键值对数目超过阈值时，进行rehash
if (++size > threshold)
resize();
// 插入后回调
afterNodeInsertion(evict);
return null;
}其中，如果插入桶中的数量大于或者等于TREEIFY_THRESHOLD - 1,将该桶中的链表转化成红黑树（红黑树的知识点在这里不总结了，以后会专门写下一篇，然后再补充吧）。此外如果键值对的数目超过了阈值我们还需要对HashMap进行重构。这两个方法有点恶心，请一定耐心观看。
/**
* 对table进行初始化或者扩容。
* 如果table为null，则对table进行初始化
* 如果对table扩容，因为每次扩容都是翻倍，与原来计算（n-1）&hash的结果相比，节点要么就在原来的位置，要么就被分配到“原位置+旧容量”这个位置
* resize的步骤总结为:
* 1.计算扩容后的容量，临界值。
* 2.将hashMap的临界值修改为扩容后的临界值
* 3.根据扩容后的容量新建数组，然后将hashMap的table的引用指向新数组。
* 4.将旧数组的元素复制到table中。
*
* @return the table
*/
final Node<K,V>[] resize() {
// 将旧的table保存到
Node<K,V>[] oldTab = table;
// 获取原来数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取原数组扩容的临界值
int oldThr = threshold;
// 声明新的数组长度、新的扩容临界值
int newCap, newThr = 0;
if (oldCap > 0) {
// 如果原来的数组长度大于最大值(2^30)
if (oldCap >= MAXIMUM_CAPACITY) {
// 扩容临界值提高到正无穷
threshold = Integer.MAX_VALUE;
// 无法进行扩容，返回原来的数组
return oldTab;
}
// 如果现在容量的两倍小于MAXIMUM_CAPACITY且现在的容量大于DEFAULT_INITIAL_CAPACITY
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 临界值变为原来的2倍
newThr = oldThr << 1; // double threshold
}
//如果旧容量 <= 0，而且旧临界值 > 0
else if (oldThr > 0) // initial capacity was placed in threshold
//数组的新容量设置为老数组扩容的临界值
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//如果旧容量 <= 0，且旧临界值 <= 0，新容量扩充为默认初始化容量，新临界值为DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize上限
if (newThr == 0) {
// 在当上面的条件判断中，只有oldThr > 0成立时，newThr == 0
// ft为临时临界值，下面会确定这个临界值是否合法，如果合法，那就是真正的临界值
float ft = (float)newCap * loadFactor;
// 当新容量< MAXIMUM_CAPACITY且ft < (float)MAXIMUM_CAPACITY，新的临界值为ft，否则为Integer.MAX_VALUE
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 将扩容后hashMap的临界值设置为newThr
threshold = newThr;
@SuppressWarnings({"unchecked"})
// 创建新的table，初始化容量为newCap
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 修改hashMap的table为新建的newTab
table = newTab;
// 上面的代码是用来确定新的table大小，下面的数组是用来从旧数组中遍历复制元素
// 如果旧table不为空，将旧table中的元素复制到新的table中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 如果旧桶不为null，使用e记录旧桶
if ((e = oldTab[j]) != null) {
//将旧桶置为null
oldTab[j] = null;
// 如果旧桶中只有一个node
if (e.next == null)
// 将e也就是oldTab[j]放入newTab中e.hash & (newCap - 1)的位置
newTab[e.hash & (newCap - 1)] = e;
//如果旧桶中的结构为红黑树
else if (e instanceof TreeNode)
// 将树中的node分离
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 如果旧桶中的结构为链表,链表重排，jdk1.8做的一系列优化
// 如果扩容后，元素的index依然与原来一样，那么使用这个head和tail指针
Node<K,V> loHead = null, loTail = null;
// 如果扩容后，元素的index=index+oldCap，那么使用这个head和tail指针
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;
}
// 原索引+oldCap放到桶中
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
/**
* 将链表转化为红黑树
* @param tab 桶中链表数据
* @param hash 结点哈希值
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 如果桶数组table为空，或者桶数组table的长度小于MIN_TREEIFY_CAPACITY，不符合转化为红黑树的条件
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 对数组进行扩容或者初始化
resize();
// 如果符合转化为红黑树的条件，而且hash对应的桶不为null
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 红黑树的头结点、尾结点
TreeNode<K,V> hd = null, tl = null;
do {
// 替换链表node为TreeNode，建立双向链表
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有了较为深刻的认识了，赶紧为自己鼓鼓掌吧。
再继续学习HashMap之前，我们还要思考一个问题，HashMap在多线程的情况下，链表成环问题。这个问题是在1.7版本中的java出现的，目前1.8已经对HashMap做了改进。具体问题在这里不做说明了。哈哈！
接下俩我们看一下get这个方法吧：
/**
* 返回指定的key映射的value，如果value为null，则返回null
* get可以分为三个步骤：
* 1.通过hash(Object key)方法计算key的哈希值hash。
* 2.通过getNode( int hash, Object key)方法获取node。
* 3.如果node为null，返回null，否则返回node.value。
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node<K, V> e;
//根据key及其hash值查询node节点，如果存在，则返回该节点的value值
return (e = getNode(hash(key), key)) == null ? null : e.value;
}看到这么少的代码是不是有种感动要死的赶脚，但是别急getNode这个方法不是还没看呢么？但是也快结束了，哈哈。
/**
* 根据key的哈希值和key获取对应的节点
* getNode可分为以下几个步骤：
* 1.如果哈希表为空，或key对应的桶为空，返回null
* 2.如果桶中的第一个节点就和指定参数hash和key匹配上了，返回这个节点。
* 3.如果桶中的第一个节点没有匹配上，而且有后续节点
* 3.1如果当前的桶采用红黑树，则调用红黑树的get方法去获取节点
* 3.2如果当前的桶不采用红黑树，即桶中节点结构为链式结构，遍历链表，直到key匹配
* 4.找到节点返回null，否则返回null。
*
* @param hash 指定参数key的哈希值
* @param key 指定参数key
* @return 返回node，如果没有则返回null
*/
final Node<K, V> getNode(int hash, Object key) {
Node<K, V>[] tab;
Node<K, V> first, e;
int n;
K k;
// 如果哈希表不为空，而且key对应的桶上不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 如果桶中的第一个节点就和指定参数hash和key匹配上了
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
// 返回桶中的第一个节点
return first;
// 如果桶中的第一个节点没有匹配上，而且有后续节点
if ((e = first.next) != null) {
// 如果当前的桶采用红黑树，则调用红黑树的get方法去获取节点
if (first instanceof TreeNode)
return ((TreeNode<K, V>) first).getTreeNode(hash, key);
// 如果当前的桶不采用红黑树，即桶中节点结构为链式结构
do {
// 遍历链表，直到key匹配
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
// 如果哈希表为空，或者没有找到节点，返回null
return null;
}以上代码大致就是按照HashMap这种特殊数组+链表+红黑树数据结构所设计的查找元素方式。HashMap的的重点在于其特殊的扩容机制、数据结构。我们在前面已经阐述的较为详细了。关于线程安全等一系列问题我在前面的概述中说的已经比较详细了，不在说了。
欢迎留言和指教，看了两天代码。颈椎竟然出现了问题......老子身强体壮为毛选择当个程序员。