最近看《java核心思想》看到了容器部分，本书着重描述了HashMap 的实现机制，对于Map，我们的固有印象便是存取很快，特别是HashMap，我们知道底层是哈希表结构。但HashMap具体怎么维护这个数据结构，这是我们今天要记录的问题。
HashMap的基本组成
要知道HashMap为什么存取性能优异，就要了解它内部的构造。hashmap实质是由 数组+链表 构成，在java 8 中，链表被优化成 在数据量比较大的情况下转变成红黑树。下图是HashMap的基本结构。
对着图，我们分析它内部一些必要组成结构。
数组table
/**
* 这个表数组，会在初次使用的时候初始化,并且在必要的时候重新设置大小,当空间重新分配时，长度总是2的倍数
* The table, initialized on first use, and resized as
* necessary. When allocated, length is always a power of two.
*/
transient Node<K,V>[] table;所以HashMap的第一层，是一个数组table ，通过构造器你会发现，数组table 不会在构造器内被初始化，而是在真正业务操作时初始化，比如put。数组table里面存的是Node<K,V>，这也就是HashMap的第二层。
Node<K,V>
Node<K,V>是一个内部类，结构如下：
可以看出这是一个自定义的容器 – HashMap真正存每个key-value数据的地方。通过 最前面的示例图和 table，node的简单介绍，我们可以总结出，hashmap先是一个数组，然后每个数组内部是一个node链表，我们的key-value数据被存放在每个Node节点中，
/**
* Basic hash bin node, used for most entries.
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //key的hash值
final K key; //key
V value; //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的存取机制
这张图以put方法为例，精要的总结了HashMap存的流程，但是我们是不是看的一脸懵逼？那我们分步骤讲解.
当我们调用put方法时，我们需要先计算key的hash值
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}hashcode的意义和设计
hash()方法其实是调用了key的hashCode方法，每个Object都有equals()和hashCode方法，正常来说，我们都需要复写这个方法。普通的线性查找算法从头查到尾， 效率很慢，如果我们给每个key带上一个索引，程序根据这个索引直接找到这个key，便可以直接锁定这个值，这个索引便是我们说的hash值。折射到hashmap里的设计，数组table的下标保存的不是key，而是hash值， 数组的随机访问很快，通过索引我们可以做到快速定位。
根据《java编程思想》的说法，如果我们不复写hashcode方法，默认的返回值是对象地址，也就是说hashcode返回的都是唯一值，但是这样设计会要求数组table的空间很大，并不利于效率,最好的方法hash值的设计应该根据对象内容来设计，对象内容一致的hash值应该要一样。
这是Integer的hashcode，返回的就是实际的内容
public static int hashCode(int value) {
return value;
}但是还有一个问题，根据内容生成的hash值不就存在hash值相同的情况了吗，table数组怎么存啊？这种情况称为hash冲突，但是还记得上面说的 hashmap是由数组+链表组成的吗？所以hash值一样的数据被组成了一个链表，先通过hash值确定对象在table数组中的具体位置，然后通过equals()方法对链表上的数据进行一一比较，最终确定这个对象应该存在的位置。这种数据结构比从头到尾的线性查找更有效率。
所以在HashMap中 元素的操作都是通过 hashCode() 和 equals()组合来确定元素位置的。
再回到HashMap中的hash方法中，里面除了提取对象的hashcode值，自己也做了一些位运算处理.
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}HashMap扩容机制
计算完hash后开始调用putVal方法，因为在调用get put之前，数组table是没有初始化的，所以会先做一个数组初始化操作，初始化操作都在resize()方法中进行，但是resize方法不止是初始化数组，更重要的是后期数组table的扩容操作。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;HashMap默认的初始化大小为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16下面这段代码
final Node<K,V>[] resize() {
//现在的table数组
Node<K,V>[] oldTab = table;
//现在的table数组容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//threshold 为扩容的临界点，公式为 capacity(现在的table数组容量) * load factor(装载因子，衡量hashmap满的程度，默认0.75)，超过临界点，就会扩容
int oldThr = threshold;
int newCap, newThr = 0;
//如果现在的table数组容量大于0
if (oldCap > 0) {
//如果table长度大于规定的最大容量，就不扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则newCap变成当前容量的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//newThr 变成当前扩容临界点的2倍
newThr = oldThr << 1; // double threshold
}
//这个是针对创建hashmap时指定了initialCapacity 和 loadFactor的情况，会将容器扩容为计算好的threshold大小
//HashMap(int initialCapacity, float loadFactor)
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//table还未初始化，初始化为系统默认大小，并且计算好扩容的临界值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
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);
}
//总之，之前的都在计算newThr和newCap，确保它们有有意义的值。这样做是为了生成新的table，众所周知，当容器扩容时，为了保证kv元素能均匀的分布，我们需要重新计算迁移元素。并把旧的table释放。
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//根据计算的newCap生成新的table
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)
// 数据的迁移注意看这个公式，这也是计算某个kv元素存在table数组具体位置的公式 e.hash & (newCap - 1)
// 假设初始容量为16 ，A元素没扩容前hash值为15，则A在原来的table上的位置为(15& (16-1)) = 15,那么扩容后为32，则新的hash值为 15&(32-1) = 15，这个元素不用做变动；
// B元素没扩容前hash值为20，则B在原来的table上的位置为(20& (16-1)) = 4，那么扩容后新的hash值为20&(32-1) = 20，这个元素正好向右偏移了oldCap个单位。
//这个巧妙的设计保证了一半元素原地不动，一半元素向右偏移了oldCap个单位（此结论未作严谨验证，但是意在表达hashmap扩容后，元素的迁移思路）
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;
}hashmap扩容机制都写在了上面代码的注释里，光从容器扩容的代码我们就可以大概了解到hashmap 的运作原理，其中包括了：
- capacity，loadFactor，threshold的基本概念和作用
- kv元素如何确定在table中的位置以及扩容后的位置
走完resize()方法，我们继续走完putVal方法
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;
//通过公式e.hash & (newCap - 1)确定kv元素的位置，如果该位置没有其它元素，直接在table[i]中插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果有其它元素
else {
Node<K,V> e; K k;
//如果旧kv的key跟新kv的key内容完全一样，则先用e记录，后面会覆盖其value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果该链表是一个红黑树结构，且两个key内容不相等，则会用putTreeVal将这新的记录插入到红黑树中去
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果这个链表不是红黑树结构，且两个key内容不相等，会进入这段代码
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//这里要注意，在java8中，如果一个链表里的kv元素大于8，则会用treeifyBin将这个链表转化成红黑树结构，红黑树的查询效率更高。
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内容一样需要做覆盖处理的具体代码
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;
}HashMap的取过程
通过漫长的代码分析，我们走完hashmap是如何存一个元素的，下面再看看它是如何取的。
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//依旧从公式(n - 1) & hash 确定kv元素的具体位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//总是检查第一个元素，如果第一个直接key内容完全匹配上，就返回
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//如果第一个元素取不到，且接下来是个红黑树结构，就用getTreeNode方法去取值
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果不是红黑树结构，就循环链表去取值
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}可以看出，存和取是一个互逆过程，两者原理相似。
结语
这篇文章从代码层面解释了HashMap的存取机制，它利用了数组的高随机访问能力，但是对于数据大容量问题，又用 链表/红黑树 与数组配合 作为解决方案，可见HashMap设计的精妙之处。
本文内容也参考了该文章，对该文章作者表示感谢
http://www.jianshu.com/p/aa017a3ddc40