1. 概述
在Android开发中，HashMap也是常用的集合类，一直以来只是知道怎么用，以及HashMap是线程不安全的，但是对于内部是如何实现却没有去关注过。此篇将对HashMap的源码进行解析，进一步了解HashMap的实现原理。在JDK1.8之前的版本HashMap的实现和JDK1.8的HashMap实现方式存在较大差异，这里只解析JDK1.8中HashMap的源码。
2. HashMap 的使用
先看以下例子：
package cn.zzw.linkhashmap;
import java.util.*;
public class TestHashMap {
public static void main(String[] args) {
HashMap<Integer, String> hm = new HashMap<>();
hm.put(0, "zzw0");
hm.put(1, "zzw1");
hm.put(2, "zzw2");
hm.put(null, "zzwNull");
hm.put(3, "zzw3");
hm.put(7, "zzw7");
hm.put(4, "zzw4");
hm.put(5, "zzw5");
hm.put(6, "zzw6");
hm.put(8, null);
Set<Map.Entry<Integer, String>> set = hm.entrySet();
Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
Integer key = (Integer) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
}
}
运行结果：
key:null,value:zzwNull
key:1,value:zzw1
key:2,value:zzw2
key:3,value:zzw3
key:4,value:zzw4
key:5,value:zzw5
key:6,value:zzw6
key:7,value:zzw7
key:8,value:null此例子中包含HashMap的创建，数据的添加，以及对HashMap中的数据进行迭代。
HashMap的构造方法：
| Constructor and Description |
|---|
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 |
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 |
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 |
HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。 |
HashMap 常用的API有如下：
| Modifier and Type | Method and Description |
|---|---|
void | clear() 从这张地图中删除所有的映射。 |
Set<Map.Entry<K,V>> | entrySet() 返回此地图中包含的映射的 |
V | get(Object key) 返回到指定键所映射的值，或 |
boolean | isEmpty() 如果此地图不包含键值映射，则返回 true 。 |
Set<K> | keySet() 返回此地图中包含的键的 |
V | put(K key, V value) 将指定的值与此映射中的指定键相关联。 |
V | remove(Object key) 从该地图中删除指定键的映射（如果存在）。 |
boolean | remove(Object key, Object value) 仅当指定的密钥当前映射到指定的值时删除该条目。 |
int | size() 返回此地图中键值映射的数量。 |
以上方法包含了平时在工作中HashMap常用的方法。详细的API文档可以参考：https://docs.oracle.com/javase/8/docs/api/
从以上的例子中可以看出：
HashMap存储的是key-value的键值对，允许key为null，也允许value为null。
3. HashMap 的源码解析
3.1 基本属性：
默认初始容量为 16 和默认负载因子为 0.75。
// 默认初始容量为16，必须为2的幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量，必须为2的幂
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表节点转换红黑树节点的阈值, 9个节点转
static final int TREEIFY_THRESHOLD = 8;
// 红黑树节点转换链表节点的阈值, 6个节点转
static final int UNTREEIFY_THRESHOLD = 6;
// 转红黑树时, table的最小长度
static final int MIN_TREEIFY_CAPACITY = 64;3.2 构造方法：
3.2.1 无参构造方法
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}在无参构造方法中，将负载因子赋值为默认的负载因子0.75。
3.2.2 指定容量大小以及负载因子的构造方法：
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);
}首先判断指定的容量值 initialCapacity 是否大于0，如果小于0，则抛出异常 IllegalArgumentException。当 initialCapacity 大于0以后，继续判断 initialCapacity 是否超过允许设置的最大值，如果比允许设置的最大值还大，则把initialCapacity 的值赋值为允许设置的最大值 MAXIMUM_CAPACITY。
其次判断指定的负载因子的值是否是一个数字以及值是否大于0，否则抛出异常。
最后，对 threshold 进行赋值，threshold 代表下次扩容阀值。这里通过调用方法 tableSizeFor(initialCapacity) 进行赋值，方法的参数为 HashMap 的容量。
tableSizeFor 方法：返回大于输入参数且最近的2的整数次幂的数。比如输入10,11或者15，则都返回16。
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;
}3.2.3 指定容量大小的构造方法：
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}在此构造方法中，调用的 3.2.2 中的构造方法。负载因子为默认的负载因子0.75 。
3.2.4 有一个Map类型参数的构造方法
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}此构造方法中，将默认的负载因子(0.75)赋值给 loadFactor 。调用 PutMapEntries() 来完成HashMap的初始化赋值过程。(这里先不探究 PutMapEntries()方法。)
3.3 Put 方法：
在平时开发过程中，最常用的HashMap进行初始化方法为 3.2.1 无参构造方法 。当对 HashMap 进行初始化后，就该对HashMap 进行赋值了。put() 方法就是用于对HashMap中存入key-value形式的值。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}key，value都为泛型，通过2中HashMap的用例，可以看出 key，value的值可以为 null 。在put 方法中调用的 putVal()，在此方法调用前，先对key调用了 hash()方法。
hash() 方法:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}key不为空的话，拿到 key 的 hashCode 值：h = key.hashCode()，并通过 (h = key.hashCode()) ^ (h >>> 16) 计算 key 的 hash 值。
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; //1
if ((tab = table) == null || (n = tab.length) == 0) //2
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) //3
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k; //4
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //5
e = p;
else if (p instanceof TreeNode) //6
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) { //7
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 //8
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //9
if (++size > threshold) //10
resize();
afterNodeInsertion(evict);
return null;
}下面逐一解释以上的代码：
注释1：声明变量
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 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;
}
}Node 是 HashMap 中一个静态类，是一个带有3个值，hash、key、value 和另外一个Node 对象引用的HashMap子元素结构，装的每个 key-value 就用一个 Node 对象存放。
注释2：table 为 Node 类型的数组。
transient Node<K,V>[] table;将 table 赋值给变量 tab ，并判断 tab 是否为空。一开始 table 是为空的，所以会执行：
n = (tab = resize()).length;调用了方法 resize()，返回大小为16的Node数组。resize()留着后面解析。这里 n = 16。tab 为大小为 16 的 Node 数组。
注释3：
if ((p = tab[i = (n - 1) & hash]) == null) i 取值为范围为 0~ n-1，初始时候 n = 16 ，虽然 tab 不为空，但是里面的值都为 null，所以会执行到：
tab[i] = newNode(hash, key, value, null);方法newNode()的作用是：new一个节点Node，放在数组里，i 是上一步中计算的索引。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}注释4：
如果当前存的 key计算出来的索引值已经存过了：(p = tab[i = (n - 1) & hash]) 不为空。意味着发生了 hash 冲突，从注释4开始就是处理冲突的。创建了 Node 类型的元素 e，以及泛型 k。
Node<K,V> e; K k;注释5：
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;p 是发生冲突时，数组该索引位置的元素。
p = tab[i = (n - 1) & hash])判断 p 的 key 与新元素的 key 是否相等。
((k = p.key) == key || (key != null && key.equals(k)))判断 p 的 key 的 hash 值与新元素的 hash 是否相等。
如果上面的判断都相等，则表示存了一样的 key，直接赋值给注释4创建的 e。
注释6：
p instanceof TreeNode判断 p 是否是 TreeNode 类型，如果是 TreeNode类型，则执行：
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); TreeNode 是静态的内部类，就是红黑树的节点，如果是红黑树的节点，则调用方法 putTreeVal() 往红黑树中添加元素。
注释7：
如果 key 不同，且不是红黑树，则通过循环遍历到链表的尾部。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
...
...
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}当遍历到链表的尾部后，在尾部插入新的节点。
p.next = newNode(hash, key, value, null);如果链表的长度超过 TREEIFY_THRESHOLD(8)，则调用方法 treeifyBin() 将链表转换为红黑树：
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
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);
}
}注释8：
最后判断 e 是不是空，当 e 不为空，则将新的值 value 进行覆盖，e 为空，则就是无相同的 key 且将数据成功的插入。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}注释9：
modCount 是用于记录数据结构变动的次数，操作一次则加1。
transient int modCount;注释10：
if (++size > threshold)
resize();添加成功一次后，size 加 1。这里 size 代表 HashMap 存储的 key-value 对的个数。
/**
* The number of key-value mappings contained in this map.
*/
transient int size;然后将 size 与扩容的阈值 threshold 进行对比，size 大于 threshold，则调用方法 resize() 进行扩容。
3.4 resize 方法：
resize 方法在 HashMap 的源码中是负责进行扩容的，返回的是一个新的 Node 类型的数组。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //1
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) { //2
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) //3 initial capacity was placed in threshold
newCap = oldThr;
else { //4 zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { //5
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //6
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) { //7
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)
((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;
}注释1：
创建 oldTab 来存储 Node<K,V> 类型的数组 table；创建 oldCap 来存储旧的容量；创建 oldThr 来存储扩容的阈值 threshold；
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;创建 newCap，newThr 来存储新的容量以及新的扩容阈值，并做初始化为 0。
int newCap, newThr = 0;注释2：
当旧容量大于0，则该 HashMap 中已经有元素。
if (oldCap > 0) {
...
...
}如果旧容量超过最大容量，则扩容的阈值为 Integer 的最大值，就不在进行扩容了：
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注释3：
如果容量 oldCap 小于等于0，则会进行判断注释3。当用 3.2.2 指定容量大小以及负载因子的构造方法对 HashMap 进行初始化，table 大小为0，容量为调用方法 tableSizeFor 后返回的大小。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;注释4：
如果用3.2.1 无参构造方法对HashMap进行初始化，则会走到注释4：
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}注释5：
如果新的阈值为0，则重新设置阈值：
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}注释6：
把 HashMap 阈值设置为新的阈值，并且初始化新的数组，并将初始化后的数组赋值给 table。如果是进行第一次初始化，则不会再走后面的代码，resize 就只走到如下代码，则扩容后的新数组。
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;注释7：
当 HashMap 不为空时候，所有在oldTab上的元素通过遍历转移到新的table中。
首先创建临时变量：
Node<K,V> e;并将数组下标为 j 的值赋值给变量 e，当 e 不为空的时候，将旧值置为空：
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
...
...如果 e 没有下一个元素，即链表只有一个元素，则直接进行赋值：
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;如果 e 是红黑树的节点，则将树转移到 newTab 中：
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);如果是链表不为空，则对链表进行复制，首先 5 个 Node 类型的引用：
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;接着采用do-while语句进行遍历链表中的节点：
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);在此循环中，通过判断 (e.hash & oldCap) == 0 的结果，执行不同的逻辑：
当 (e.hash & oldCap) == 0 的值为 true，将节点放入链表 lo；
当 (e.hash & oldCap) == 0 的值为 false，将节点放入链表 hi；
通过此循环后，节点就被放入了两个新的链表之中，并且
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}如果链表 lo 非空，则把链表放到新 table 的 j 位置上；
如果链表 hi 非空，则把链表放到新 table 的 j+oldCap 位置上；
这样就完成了扩容，并返回一个新的数组。
3.5 get 方法：
get 方法用于通过 key 的值去查找 HashMap 中对应的节点的值：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}通过 getNode() 方法去查找对应的节点：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { //1
if (first.hash == hash && //2 always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) { //3
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：
(tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null将 table 赋值给临时变量 tab，并且数组的长度大于 0，并且传入的 key 的 hash 值在数组中找到不为空的的元素：
注释2：
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;在 hash 值相等的情况下，判断key对象是否相等：是否为同一对象（==）/ 不同对象调用equals()进行比较。
注释3：
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);
}如果是红黑树的节点，则从红黑树中获取：
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}红黑树寻找节点的方法：
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
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;
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;
}如果是链表，则通过 do-while 循环，从链表中取出节点。
4. 总结
HashMap 中，最常用的是无参数的构造方法。通过无参数的构造方法，默认创建一个 Node 类型的空数组，且默认设置负载因子为0.75。
当第一次调用方法 put() 添加元素的时候，会创建一个长度大小为 16 的数组，且设置扩容阈值为 12（16*0.75）。
当 HashMap 的节点个数不大于 8 的时候，底层是数组+链表来实现，当 HashMap 的节点个数大于 8 的时候，链表将转化为红黑树的结构，HashMap 每次扩容都扩容为原容量的两倍。
由于 HashMap 会进行 resize 操作，在resize 操作中会重新计算元素的 index，在多线程操作中存在多线程的不安全问题。
参考：
https://www.cnblogs.com/zhaojj/p/7805376.html
https://github.com/LRH1993/android_interview/blob/master/java/basis/hashmap.md
https://segmentfault.com/a/1190000015812438?utm_source=tag-newest
237
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
