HashMap1.7和1.8变动比较多。
关于HashMap 1.7的版本，倪升武的博客总结的很好。
这里我主要来介绍一下1.8中的HashMap。由于HashMap源码太长，我只挑选了部分进行分析，如果有没有分析到的重点难点或者大家有疑问的地方，希望大家私信给我，大家共同进步~
HashMap的存储思想演化
在1.7中，HashMap是以“数组+链表”的基本结构来存储key和value构成的Entry单元的。其中链表结构的存在是用来处理hash碰撞的。这种结构有它的优点，比如容易实现等。但是我们可以设想这样一种情况，如果说有成百上千个节点在hash时发生碰撞，存储一个链表中，那么如果要查找其中一个节点，那将不可避免的花费 o（n） 的时间复杂度来进行查找。基于这点，1.8中将HashMap的基本结构进行了改善，其中hashMap的基本结构依然是“数组+链表”，但是当hash碰撞太多以至于链表过长的时候，链表结构将演化成树（具体来说应该是红黑树）的结构。我们都知道，红黑树是二叉查找树平衡形式的一种，因此查找性能较链表来说，有了很大提升。
其次，在1.7中，是使用Entry这个类作为基本存储单元的，在1.8中，可能为了配合红黑树的使用，改进成了Node这个类，当然，差不多只是名字变了而已，类内部实现的形式差别不是很大。
源码分析
前言
源码中的很多备注写的非常好，这里挑出几个与大家一起学习：
package java.util;
/**
* Hash table based implementation of the <tt>Map</tt> interface. This
* implementation provides all of the optional map operations, and permits
* <tt>null</tt> values and the <tt>null</tt> key. (The <tt>HashMap</tt>
* class is roughly equivalent to <tt>Hashtable</tt>, except that it is
* unsynchronized and permits nulls.) This class makes no guarantees as to
* the order of the map; in particular, it does not guarantee that the order
* will remain constant over time.
* HashMap是一个实现Map接口的哈希表，并且实现了map集合的所有操作，允许key和value为null
* 除了线程安全性和null设置方面的不同，HashMap和HashTable大致是相同的。这个类
* 不保证map中的顺序。尤其是，它也不能保证顺序的恒久不变。
* <p>This implementation provides constant-time performance for the basic
* operations (<tt>get</tt> and <tt>put</tt>), assuming the hash function
* disperses the elements properly among the buckets. Iteration over
* collection views requires time proportional to the "capacity" of the
* <tt>HashMap</tt> instance (the number of buckets) plus its size (the number
* of key-value mappings). Thus, it's very important not to set the initial
* capacity too high (or the load factor too low) if iteration performance is
* important.
* 只要hash算法能够将数据散列的足够好，那么get和put这种基本操作的用时是固定的。
* 而集合视图的遍历需要的时间与HashMap实例的大小是成比例的。因此，如果遍历操作
* 非常重要的话，不要讲初始容量设置太大（或者将负载因子设置太低）是很重要的
*/上面是关于HashMap类源码中的几点说明，本人语言表达能力比较差，以上可能有些翻译的不是很好，大家凑合看吧。
1.HashMap中的几个成员变量
private static final long serialVersionUID = 362498820763181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16，最小容量：16
static final int MAXIMUM_CAPACITY = 1 << 30;//HashMap的最大容量
/** * The load factor used when none specified in constructor. */
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的负载因子
/** * The bin count threshold for using a tree rather than list for a * bin. Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal about conversion back to plain bins upon * shrinkage. */
//树的门阀值，即当链表的长度超过这个值的时候，进行链表到树结构的转变
static final int TREEIFY_THRESHOLD = 8;
/** * The bin count threshold for untreeifying a (split) bin during a * resize operation. Should be less than TREEIFY_THRESHOLD, and at * most 6 to mesh with shrinkage detection under removal. */
//当低于这个值时，树变成链表
static final int UNTREEIFY_THRESHOLD = 6;
/** * The smallest table capacity for which bins may be treeified. * (Otherwise the table is resized if too many nodes in a bin.) * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts * between resizing and treeification thresholds. */
//下面这个值的意义是：位桶（bin）处的数据要采用红黑树结构进行存储时，整个Table的最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
//分配的时候，table的长度总是2的幂
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
/** * The number of times this HashMap has been structurally modified * Structural modifications are those that change the number of mappings in * the HashMap or otherwise modify its internal structure (e.g., * rehash). This field is used to make iterators on Collection-views of * the HashMap fail-fast. (See ConcurrentModificationException). */
//这个值用于快速失败机制
transient int modCount;
//门限阀值，计算方法：容量*负载因子
int threshold;
2.几个比较重要的方法
下面我先挑几个比较重要又难以理解的方法源码来说一下：
//返回根据给定的目标容量所计算出来的最接近的2的幂，这有利于改善hash算法
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;
}
get（）方法：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//这里可以解释一下为什么要求table的长度为2的幂
//n为2的幂，那么化成二进制就是100...00，减一之后成为0111..11
//对于小于n-1的hash值，索引位置就是hash，大于n-1的就是取模，这样在indexFor（）方法里可以提高&运算的速度
//且最后一位为1，这样保证散列的均匀性
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 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;
}
插入操作：
//进行插入操作，分为三种情况，1.插入位置无数据，直接存入 2.插入位置有数据，但是较少且符合链表结构存储的条件，那么以链表操作存入
//3.插入位置有数据，但是以树结构进行存储，那么以树的相关操作进行存入
//较1.7的put相比，复杂了很多，不过却换取了查找时的性能提升。
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;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
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 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;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
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;
}resize（）操作：
/** * Initializes or doubles table size. If null, allocates in * accord with initial capacity target held in field threshold. * Otherwise, because we are using power-of-two expansion, the * elements from each bin must either stay at same index, or move * with a power of two offset in the new table. * * @return the table */
/** *初始化或者将size扩至2倍大小。如果满了，就分配符合初始容量目标下的门阀值 *否则，因为我们是进行2的幂的扩展操作，每个位桶处的数据要么呆在相同的索引处，要么移动 *处，要么移动2的幂的位移量。 */
final Node<K,V>[] resize() {
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;//超过1>>30大小,无法扩容只能改变 阈值
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold //门限值*2
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
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);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//table在这里产生了。
table = newTab;//下面对原table中已存储的数据进行迁移，分树和链表2种情况处理
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)
newTab[e.hash & (newCap - 1)] = e;//将单节点移动到新位置
else if (e instanceof TreeNode) //下面是分开2种情况操作，一种是发生碰撞的节点以树结构进行存储，另一种是以链表结构存储
((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) {//根据hash值与oldCap的运算结果，将链表中集结的元素分开
if (loTail == null) //运算结果为0的元素，用lo记录并连接成新的链表
loHead = e;
else
loTail.next = e;
loTail = e;
}
else { //运算结果不为0的数据，
if (hiTail == null) //用li记录
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead; //lo仍然放在“原处”，这个“原处”是根据新的hash值算出来的。
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;//li放在j+oldCap位置
}
}
}
}
}
return newTab;
}树化操作：
//对链表进行树结构的转化存储
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
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);
}
}
值得一提的是，在1.8的HashMap中新添了一个内部静态类TreeNode，该类继承了LinkedHashMap.Entry。
1.8的HashMap源码较多，一共有2380行，这里我挑选了几个比较重要的来说了一下，其余的并不是很难理解。
小总结：
- 1.8中的HashMap基本实现结构是“数组+链表”，不过当链表过长时（链表长度超过8），会演化成红黑树。
- 源码要求HashMap底层实现数组的长度为2的幂，原因是可以得到较好的散列性能。
- 在HashMap进行扩容时，会进行2倍扩容，而且会将哈希碰撞处的数据再次分散开来，一部分依照新的hash索引值呆在“原处”，一部分加上偏移量移动到新的地方。
