今儿来看一个老生常谈的问题——HashMap的原理。
其实对于java集合类的源码解析只要盯着三块就能掌握：
- 集合的存储结构
- 如何取出
- 如何放入
一、存储结构
HashMap的存储结构在jdk1.8版本的时候是发生了变动的：
hashmap底层是一个数组加链表的结构。且当链表长度8就会转化为红黑树（元素总数超过64，不然会优先扩容），减少到6个时，就退化为链表。
因此其有对应的两类节点：
-
普通节点Node
/** *已省略get/set方法 */ static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V 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 int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } /** *常用的对象判断相等逻辑，先判断引用，其次针对值 */ 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; } } -
树节点TreeNode
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } //其他对红黑树操作的方法省略 }而HashMap中重要的类变量:
-
//默认容量 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4 -
static final int MAXIMUM_CAPACITY = 1 << 30; -
//默认的加载因子0.75，乘以数组容量得到的值，用来表示元素个数达到多少时，需要扩容 static final float DEFAULT_LOAD_FACTOR = 0.75f; -
//树化和链化 static final int TREEIFY_THRESHOLD = 8; static final int UNTREEIFY_THRESHOLD = 6; -
//最小树化容量 static final int MIN_TREEIFY_CAPACITY = 64; -
//存放所有Node节点的数组 transient Node<K,V>[] table -
//每次结构改变时，都会自增，fail-fast机制，这是一种错误检测机制。 //当迭代集合的时候，如果结构发生改变，则会发生 fail-fast，抛出异常。 transient int modCount; -
//加载因子 final float loadFactor; -
//扩容阈值 = capacity * load factor int threshold;
二、存入原理
以HashMap常用的存入方法put(K key, V value) 为例，存入主要调用的都是 putVal :
-
public V put(K key, V value) { //先处理key，返回hash码 return putVal(hash(key), key, value, false, true); } -
//这里onlyIfAbsent如果为true，表明不能修改已经存在的值，因此我们传入false //evict不用管 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //判断table是否为空，如果空的话，会先调用resize扩容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //根据当前key的hash值找到它在数组中的下标 //p==null则直接插入数组 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; //判断当前位置元素的hash值是否等于的hash，并且判断他们的key值也相等， if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //存储根据hash值找到的节点，以便替换 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的话，直接退出循环，跳转到①处 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } //说明发生了碰撞，e代表的是旧值，因此节点位置不变，但是需要替换为新值 if (e != null) { // existing mapping for key V oldValue = e.value; //用新值替换旧值，并返回旧值。 if (!onlyIfAbsent || oldValue == null) e.value = value; //看方法名字即可知，这是在node被访问之后需要做的操作。其实此处是一个空实现， //只有在 LinkedHashMap才会实现，用于实现根据访问先后顺序对元素进行排序，hashmap不提供排序功能 afterNodeAccess(e); return oldValue; } } //fail-fast机制 ++modCount; //如果当前数组中的元素个数超过阈值，则扩容 if (++size > threshold) resize(); //同样的空实现 afterNodeInsertion(evict); return null; }
可以看出，HashMap是懒加载的，当存入数据时会先判断是否为当前集合是否为空，如果为空则则调用 resize() 去初始化，而存入的值如果超出当前 threshold 也会调用 resize() 扩容：
final Node<K,V>[] resize() {
//旧数组
Node<K,V>[] oldTab = table;
//旧数组的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧数组的扩容阈值，注意看，这里取的是当前对象的 threshold 值，下边的第2种情况会用到。
int oldThr = threshold;
//初始化新数组的容量和阈值，分三种情况讨论。
int newCap, newThr = 0;
/*1.当旧数组的容量大于0时，说明在这之前肯定调用过 resize扩容过一次，因为hashmap是懒加载，hashmap被创建后第一次调用put方 法才会调用resize扩容，而此时容量是0，因此才会导致旧容量不为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
}
//2.说明hashmap的容量为0，但是扩容阈值不为零，这种情况只有构造hashmap是指定容量或者指定容器大小
且指定加载因子才能出现
//因为这两种方式都是将大于指定容量的最小的二次幂数赋予扩容阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3.到这里，说明 oldCap 和 oldThr 都是小于等于0的。也说明我们的map是通过默认无参构造来创建的，
//于是，数组的容量和阈值都取默认值就可以了，即 16 和 12。
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//③ 这里就是处理第2种情况，因为只有这种情况 newThr 才为0，
//因此计算 newThr（用 newCap即16 乘以加载因子 0.75，得到 12） ，并把它赋值给 threshold
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//赋予 threshold 正确的值，表示数组下次需要扩容的阈值（此时就把原来的 16 修正为了 12）。
threshold = newThr;
//我们可以发现，在构造函数时，并没有创建数组，在第一次调用put方法，导致resize的时候，才会把
数组创建出来。这是为了延迟加载，提高效率。
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//如果原来的数组不为空，那么我们就需要把原来数组中的元素重新分配到新的数组中
//如果是第2种情况，由于是第一次调用resize，此时数组肯定是空的，因此也就不需要重新分配元素。
if (oldTab != null) {
//遍历旧数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//取到当前下标的第一个元素，如果存在，则分三种情况重新分配位置
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//1.如果当前元素的下一个元素为空，则说明此处只有一个元素
//则直接用它的hash()值和新数组的容量取模就可以了，得到新的下标位置。
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//2.如果是红黑树结构，则拆分红黑树，必要时有可能退化为链表
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//3.到这里说明，这是一个长度大于 1 的普通链表，则需要计算并判断当前位置的链表
是否需要移动到新的位置
else { // preserve order
// loHead 和 loTail 分别代表链表旧位置的头尾节点
Node<K,V> loHead = null, loTail = null;
// hiHead 和 hiTail 分别代表链表移动到新位置的头尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//如果当前元素的hash值和oldCap做与运算为0，则原位置不变
if ((e.hash & oldCap) == 0) {
if (loTail == null) //刚给链表移位时，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);
//链表最后时，将null赋给链表最后一个节点的下一个节点
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//移动到新位置的一条链表，数组下标为原下标加上旧数组的容量
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总体上来说，hashMap的扩容方案是将原来的容量翻倍，而扩容阈值 = 扩容后的容量 * 加载因子
三、取数原理
通常用 get 方法获取指定目标节点：
public V get(Object key) {
Node<K,V> e;
//如果节点为空，则返回null，否则返回节点的value。这也说明，hashMap是支持value为null的。
//因此，我们就明白了，为什么hashMap支持Key和value都为null
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//首先要确保数组不能为空，然后取到当前hash值计算出来的下标位置的第一个元素
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) {
//如果是红黑树结构，则找到当前key所在的节点位置
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);
}
}
//否则，说明没有找到，返回null
return null;
}
