Java 集合——HashMap

Java 集合——HashMap

介绍

　　先前介绍了 List 集合的三种子类实现原理，今天我们来讲讲另一种数据结构——Map 集合，Map 是一种用来存储 key-value 的数据结构，每一个 key 对应了一个 value，并且同一个集合里面不允许存在相同的 key。

　　在 Java 中，常见的 Map 实现是 HashMap、HashTable、LinkedHashMap、TreeMap 和 ConcurentHashMap，下面从源码的层面上，给大家讲解 HashMap 的实现原理。

HashMap 定义

　　从 HashMap 名字中我们可以看出这是一个用 hash 表这种数据结构实现 Map 集合，涉及到 hash 表这种数据结构就需要考虑两个问题：

　　1. 使用什么算法来计算 key 的 hash 值

　　2. 出现冲突时，使用什么机制去解决冲突

　　这两个是 hash 表要考虑也是最核心的两个问题，只要搞懂了这两个问题，其实你就能够理解 HashMap 的实现原理了。

首先先来看看 HashMap 类的定义：

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final int MAXIMUM_CAPACITY = 1 << 30;
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;

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;
}
}

transient Node<K,V>[] table;
transient int size;
transient int modCount;
}

　　上面列举了 HashMap 定义的一些静态常量，这些静态常量的具体用途在下面讲解具体操作的时候会再介绍，首先需先理解 Node 的定义和其他变量的用途。

　　Node 是集合中结点的抽象，它内部封装了该结点的 key-value，同时还保存了 hash 值，key 和 hash 都是 final 域，这代表加入集合中的 key 是不可变的，要求其 hashcode 值不会发生改变，否则将可能会出现内存泄露问题。另外该结点定义中还有一个 next 域，用于指向下一个结点，这是用于解决冲突所定义的结构（其实从这个定义就可以猜想到 HashMap 是采用拉链法来解决冲突的）。

　　table 是 HashMap 的用于存储结点元素的数据结构，其实就是 hash 表，通过 size 来记录当前 hash 表存放了多少个元素。其实从这里定义可知，HashMap 的底层数据结构是数组 + 链表，所有操作都是通过操作这两个数据结构来进行的。

HashMap 的基本操作

　　map 是一种集合的数据结构，当然就需要实现集合的基本操作，那么现在就从最最基本的添加操作来讲解，通过结合源码和例子来让大家更加清晰地了解它的设计思想

put 操作

　　put 操作用于在集合添加一个 key-value 的键值对，在 HashMap 中采用数组+链表的形式来存储数据，每一个数组元素都是一个链表，该链表存储相同 hash 值的 key 结点（拉链法）。

它的主要工作流程：

1. 先通过 hash 算法计算 key 的 hash 值，再通过 hash & (n-1) 计算该 key 应该存放在数组哪一个位置

2. 若当前 index 位置上不存在元素，则代表未发生冲突，直接创建新结点存放，并作为该位置链表的头结点，结束；

3. 若当前 index 位置上存在元素，则代表发生冲突，则采用拉链法解决冲突，遍历链表查看是否存在相同的 key 元素（比较方法采用 equals 方法，null 元素特别处理），存在，则替换旧值；若不存在，则插入到链表的末尾

4. 更新当前的元素个数，若超过负载因子，则进行扩容操作

JDK1.8 的源码实现：

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<K,V>[] tab;
Node<K,V> p;
int n, i;

/*
如果当前 table 为null，则当前 hash 表未初始化，则进行初
始化操作
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;

/*
如果当前 hash 后的数组位置不存在结点，即代表还未没有发生冲突，
则创建新结点保存
*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {

/*
当前位置已经有元素，则代表出现冲突，采用拉链法解决冲突，遍历
链表查看是否存在相同的 key ，若存在，则将新值替换旧值，返回
旧值；若不存在，则在链表的末尾插入元素。
注：比较 key 是否相同，是采用 equals 方法来进行的，除 key
为 null 的情况，HashMap 是可以存放 null 元素的
*/
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null &&

4000
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)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}

// 上面的过程查询相同的 key 的结点，若找到，则执行值替换
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;

// 插入元素成功后，容量增加，若当前超过负载因子，则进行扩容操作
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

　　从上述的过程和源码，相信大家对 put 操作有一个大致的了解，那么现在再具体地来说一下一些内部的细节是如何实现，增加了哪些优化操作，以及在 jdk 1.8 为什么要这样实现。

hash 算法实现

　　从源码可以看出，hash 值是通过公式 hashcode ^ (hashcode >>> 16) 计算所得，在 JDK 1.8 前都是直接采用 hashcode，并未经过计算，该种方式保证了高 16 位全为 1，具体的优化目的其实我也不太清楚，可能可增大命中高位位置的概率。

计算 index 位置

　　要计算 index 位置，先通过 hash 算法计算 key 的 hash 值，再通过公式 hash & (n-1) 来算的，这也是 1.8 后引入的优化操作。在之前，都是通过 hash % n 来计算 index，但在 1.8 时，HashMap 的容量都要求是 2 的整数倍，并且根据公式 hash & (n-1) = hash % n，当 n = 2^i 时，& 运算比 % 运算的效率要高，因此采用 & 运算代替 % 运算计算 index 。

红黑树的引入

　　从源码部分其实可以看到增加了一些 TreeNode 的操作，这部分也是 JDK 1.8 新引入的红黑树机制。考虑当未引入红黑树时，出现冲突时采用拉链法解决冲突，那么当查找元素时则需要遍历链表找到匹配的 key，最优时查找次数为 1，最差时查找次数为 n，那么总得平均查找次数为 n/2，因此当出现较多碰撞时，HashMap 的查询性能则会下降，时间复杂度可能会去到 O(n)。

　　因为为解决决该种情况时的性能下降，JDK 1.8 引入了红黑树，红黑树也是一种较平衡的二叉树，它的插入、查找和删除的时间复杂度都为 O(logn)，具体的红黑树结构可以自行去 google 了解。因此，在 JDK 1.8 中，当添加元素时，链表元素个数大于 8 个时，则会触发将链表转换成红黑树，从而提高查询性能。

扩容操作

　　前面也提到，当当前负载大于负载因子，则会触发扩容操作。

　　那么问题就来了：为什么需要扩容？负载因子是什么？

　　首先负载因子 = 当前元素个数 / 总容量，即当前元素所占的比例。我们知道 HashMap 底层采用的数组这种结构，在有限的存储空间存放元素，当存放 n + 1 个元素时，那么至少有两个元素会存放在同一个位置，那就是说当存放的元素个数越多，发生冲突的概率就会越高，那么就会影响查询性能。因此为了降低的冲突的概率，当负载超过 75% 时，则将数组扩容，增大容量。

具体的扩容工作流程：

1. 先将当前容量增大一倍（因为都是 2 的倍数，采用 << 1 操作），创建一个新容量的新数组

2. 遍历旧数组每一个元素，对链表上的元素或红黑树上的元素进行重定位，存放到新数组中（这里面会涉及到红黑树的退化以及链表的拆分）

重定位操作是通过公式 hash & n 来进行，由于重定位的结果只有两种，要么放在原 index 位置，要么放在 index + n 位置，那么现在假设当前 n 为 2，在 1 位置上 存放了 key 为 1 和 key 为 3 的元素，即如下图：



经过扩容后，则转化为：



从图上可以看出 3 去到新数组的 3 位置，而 1 仍在 1 位置。那么现在来看 1 的二进制表示为 0001，3 的二进制表示为 0011 ，扩容后容量为 4(0100), 即计算位置的公式为 hash & 0011，那么只要当 hash 的最高位为 1，则新位置为 index + n，否则为 index。（与旧容量的对齐的最高位，当前为第二位）

扩容源码实现：

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;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}

else if (oldThr > 0)
newCap = oldThr;
else {
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 = 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)
newTab[e.hash & (newCap - 1)] = e;

// 这里进行红黑树的退化
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

// 这里进行链表的分裂，将链表根据最高位是否为1，来分配位置
else {
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;
}

　　通过 put 操作的分析其实已经能够了解 HashMap 的具体实现原理，删除和获取操作实际上也是对数组+链表+红黑树这个数据结构进行操作而已，只要理解了添加操作，对于其他操作应该也不难理解。另外的话，HashMap 的迭代器也是属于 fast-fail 类型，在遍历时，若其他线程修改了 map（导致 modCOunt 被修改），会抛出 ConcurentModifyException 。

总结

　　在 Java 中，Map 的实现子类有HashMap、HashTable、LinkedHashMap、TreeMap 和 ConcurentHashMap，HashMap 在该文章已经讲解过，LinkedHashMap 则是在 HashMap 的基础上，增加了一个链表机制来维护元素添加的顺序；TreeMap 则是可排序的 Map 集合，内部是采用红黑树来实现的。

　　而 HashTable 是一个比较古老的容器，它与 HashMap 的实现机制类似，都是采用 数组+链表的形式来实现的，不过 HashMap 增加了红黑树的实现。两者还有一个重要的区别是 HashMap 是线程不安全的，而 HashTable 是线程安全的，因为后者每一个方法都使用了 synchronize 关键字来定义。另外的话，HashTable 不支持 key 为 null 的元素，且扩容容量为原来的 1.5 倍。虽然 HashTable 是线程安全的，但同样不适用于并发环境编程，因为 synchronize 会导致性能下降，限制了并发量。因此，若要用于多线程开发，可使用 ConcurentHashMap ，它采用了分段锁和 volatile 变量来提高并发性能，关于 ConcurrentHasnMap 的实现原理可看我的这篇文章Java 集合——ConcurrentHashMap