【jdk1.8】HashMap源码分析
类的继承关系
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable其中，Map接口中规定了map类的常用方法。比如get(Object): V，put(K, V): V，isEmpty(): boolean，size(): int，remove(Objec): V 等。
Cloneable与Serializable是标识接口。
类的成员变量
/**
* 缺省的初始容量（数组长度），必须是2的幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大的容量， 用来修正如果有更大的值被设定。必须是2的幂，而且小于等于1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 缺省的填充因子，如果当前size大于当前容量（数组长度）乘以填充因子就需要扩容，扩为原来容量的两倍。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当bin中的数量大于此值的时候，就要将list转成红黑树。
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 如果经过resize或者元素被remove，而使得一个bin中的元素数量少于这个值之后就应该红黑树转成list了。
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**树的最小的容量，至少是 4 × TREEIFY_THRESHOLD = 32 然后为了避免(resizing 和 treeification thresholds) 设置成64
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 哈希数组，总是2的幂。
*/
transient Node[] table;
/**
* 存放具体元素的集。
*/
transient Set> entrySet;
/**
* 在整个map中存数的key-value对的数目。
*/
transient int size;
/**
* 整个hashmap进行结构调整的次数。用来检测并发修改异常（ConcurrentModificationException）。
*/
transient int modCount;
/**
* 当size达到这个值时将要被resize。(threshold = capacity * load factor)
*/
int threshold;
/**
* 哈希数组的填充因子。
*/
final float loadFactor; 类的构造函数
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);
}其中static final int tableSizeFor(int cap)方法返回大于给定cap的最小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;
} public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
} public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
} public HashMap(Map m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}其中final void putMapEntries(Map m, boolean evict)函数就是将m中的每个元素放入现在的hashmap中。
hashmap实现原理图
图片来源：http://www.cnblogs.com/leesf456/p/5242233.html
重要的方法
static final int hash(Object key)
注意，hashmap的hash值是由此方法计算的。而hashtable的hash值直接使用key.hashCode()。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}public V put(K key, V value)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
//如果table为空指针或者table长度为零，则resize扩容。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果数组中该哈希位为空，也就是该bin中还没有元素，则生成新节点放入该位置。此时还是在数组中。
//注意使用 (n - 1) & hash 来进行散列避免使用取余(%)的开销。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//若数组中该哈希位已经有元素。
Node e; K k;
//如果将插入的key的哈希值和该位置的key的哈希值相等，并且key也相等。（相当于插入重复元素了）
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//用e来记录该节点
e = p;
//如果该节点是树节点的类型
else if (p instanceof TreeNode)
//放入树中
e = ((TreeNode)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);
//插完之后如果该bin中的节点数过大，则应该将链表转成树形结构
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//put成功，跳出
break;
}
//如果在链表中找到了重复的key值
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//与循环刚开始的 e = p.next 配合来遍历链表
p = e;
}
}
//找到了重复的key
if (e != null) { // existing mapping for key
//保存旧值
V oldValue = e.value;
//若非仅不存在则插入
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//让LinkedHashMap回调
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
//结构修改次数增加
++modCount;
//如果节点数过多，则扩容
if (++size > threshold)
resize();
//让LinkedHashMap回调
afterNodeInsertion(evict);
return null;
}
final TreeNode putTreeVal(HashMap map, Node[] tab,
int h, K k, V v) {
Class kc = null;
boolean searched = false;
//得到根节点
TreeNode root = (parent != null) ? root() : this;
//遍历树的节点
for (TreeNode p = root;;) {
int dir, ph; K pk;
//待插入节点key的哈希值比当前key的哈希值小，方向为左子树
if ((ph = p.hash) > h)
dir = -1;
//大于当前，右子树
else if (ph < h)
dir = 1;
//找到重复的key，返回当前节点
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
return p;
//若hash值等于当前，而且调用compareComparables方法还是返回相等
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
//还未搜索过
if (!searched) {
TreeNode q, ch;
//只搜索一次
searched = true;
//在根节点为ch的子树中寻找key，找到则返回
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
//方法用尽，只能———比类名和System.identityHashCode值
dir = tieBreakOrder(k, pk);
}
TreeNode xp = p;
//根据direction选择左右子树，找到叶子节点进行插入
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node xpn = xp.next;
TreeNode x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
//兼顾树的指针与链表的指针
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
} public V get(Object key)
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
//如果bin中的第一个节点不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果第一个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) {
//如果是树的节点类型，则在树里面找
if (first instanceof TreeNode)
return ((TreeNode)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;
}
final TreeNode find(int h, Object k, Class kc) {
TreeNode p = this;
do {
int ph, dir; K pk;
TreeNode pl = p.left, pr = p.right, q;
//待寻找节点hash值比当前节点key的hash值小
if ((ph = p.hash) > h)
//在左子树中找
p = pl;
//若大，则在右子树中找
else if (ph < h)
p = pr;
//若相等做进一步判断
//如果就是当前key，则返回当前节点
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;
//当相等，还不是当前节点，而且当前节点左右子树都不空
//若调用compareComparables方法能判断出下一步的寻找方向
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;
} 这么重要怎能没有resize呢？final Node[] resize()
final Node[] resize() {
//保存当前数组
Node[] 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倍
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;
//如果数组也未分贝，阈值也未曾赋值
//使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步）
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//新阈值为零
if (newThr == 0) {
//阈值为 capacity × loadFactor
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
//为数组申请空间
@SuppressWarnings({"rawtypes","unchecked"})
Node[] newTab = (Node[])new Node[newCap];
table = newTab;
//如果之前数组初始化过
if (oldTab != null) {
//遍历数组
for (int j = 0; j < oldCap; ++j) {
Node 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)e).split(this, newTab, j, oldCap);
//链表类型
else { // preserve order
//lo == low, hi == high。由于数组翻倍了，相当于低位是老的数组，高位是新的一半。
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;
//将同一bin中的元素按照hash值扩容之后新容量的高位的末位是否为0来判断是否分割，完成rehash
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;
} 
关于上面所说的“高位”和“低位”
图片来源同上。
References
JDK1.8源码分析之HashMap（一）