HashMap也是我们使用非常多的Collection，它是基于哈希表的 Map 接口的实现，以key-value的形式存在。在HashMap中，key-value总是会当做一个整体来处理，系统会根据hash算法来来计算key-value的存储位置，我们总是可以通过key快速地存、取value。下面就来分析HashMap的存取。
一. 定义
HashMap实现了Map接口，继承AbstractMap。这是使用了模板方法模式，其中Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现，为 Map 的实现类提供了一些通用方法。
public class HashMap<K, V> extends AbstractMap<K, V>
implements Map<K, V>, Cloneable, Serializable
二. 构造函数
HashMap 有多个构造函数，在处理 threshold 和 loadFactor 时有所不同，所以在 resize() 方法在初始化时会对不同的情况采用相应的处理逻辑。
/*
* 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap
* 这个方法没有初始化 threshold 和 loadFactor
* 所以此时两个变量的值都为零，与其他构造函数不一样
*/
public HashMap() {}
// 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
public HashMap(int initialCapacity) {}
// 通过传入的 Map 构造一个使用默认的加载因子的 HashMap
public HashMap(Map<? extends K, ? extends V> m) {}
// 构造一个带指定初始容量和加载因子的空 HashMap
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException();
this.loadFactor = loadFactor;
/* tableSizeFor() 把threshold 设置为最靠近且比 initialCapacity 大的2的幂次方，
* 保证容量是2的幂次方
* HashMap 中并没有用于存储 initialCapacity 的变量
* 而且散列表的数组 table 是懒加载的，所以在初始化前使用 threshold 存储 initialCapacity
* 这种情况下在 table 初始化时会使用 threshold 作为 table 的容量
*/
this.threshold = tableSizeFor(initialCapacity);
}
三. 数据结构
我们知道在 Java中 最常用的两种结构是数组和模拟指针(引用)，几乎所有的数据结构都可以利用这两种来组合实现，HashMap 也是如此。HashMap 是一个“链表散列”，与 JDK 1.7 以及之前的版本不同，JDK1.8 在链表长度大于8时会转为用红黑树存储，当长度减少为6时又会转为用链表存储。如下是它数据结构：
哈希桶数组和节点 Node
哈希桶数组 Node<K,V>[] table使用一个用于存放链表或红黑树根节点的数组，使用哈希表进行存储。
transient Node<K,V>[] table;
Node 是 HashMap 的一个内部类，实现了 Map.Entry 接口，本质是就是一个映射(键值对)。上图中的每个黑色圆点就是一个 Node 对象。
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) {...}
public final K getKey() {...}
public final V getValue() {...}
public final String toString() {...}
public final int hashCode() {...}
public final V setValue(V newValue) {...}
public final boolean equals(Object o) {...}
}
哈希表存储
HashMap 就是使用哈希表来存储的。Java 中 HashMap 采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。
在 HashMap 获取 key 的 hashCode 时，会调用 key 的 hashCode() 方法得到其hashCode，然后再通过 hash(）方法进行二次哈希来定位该键值对的存储位置，有时两个 key 会定位到相同的位置，表示发生了 Hash 碰撞。当然 Hash 算法计算结果越分散均匀，Hash 碰撞的概率就越小，map的存取效率就会越高。
如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。那么通过什么方式来控制map使得Hash碰撞的概率又小，哈希桶数组（Node[] table）占用空间又少呢？答案就是好的 Hash 算法和扩容机制。
在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：
transient int size; // 当前 HashMap 存储的元素数量
transient int modCount; // 修改计数器，用于 fail-fast 机制
int threshold; // capacity * loadFactor，能容纳的元素极限
final float loadFactor; // 加载因子
由公式** threshold = capacity * loadFactor **可知，threshold就是在此loadFactor 和 capacity (数组长度)对应下允许存储的最大元素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，显然 loadFactor 越大碰撞就越不容易发生但会耗费更多的空间；loadFactor 越小，耗费的空间会减少但是碰撞会增多导致时间效率下降。如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1。
在 HashMap 中，哈希桶数组table的长度length大小必须为2的n次方，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参考
http://blog.csdn.net/liuqiyao_01/article/details/14475159，Hashtable 初始化桶大小为11，就是桶大小设计为素数的应用（Hashtable 扩容后不能保证还是素数）。HashMap 采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap 定位哈希桶索引位置时，也加入了高位参与运算的过程。但这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在 JDK1.8 版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高 HashMap 的性能。
方法实现
HashMap的内部功能实现很多，本文主要从根据key获取哈希桶数组索引位置、put方法的详细执行、扩容过程三个具有代表性的点深入展开讲解
1. 二次哈希 - hash() 方法
前面说过HashMap的数据结构是数组和链表的结合，HashMap 通过 hashCode 确定 key 在数组的位置。所以 HashMap 里面的元素位置分布得越均匀越好，尽量使得每个位置上的元素数量只有一个，那么当我们根据 hashCode 找到指定位置时就不用遍历链表，大大优化了查询的效率。先看看源码的实现：
static final int hash(Object key) {
int h;
// h = key.hashCode() 取 hashCode 值
// h ^ (h >>> 16) 将高位与低位进行异或，
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
在 JDK1.8 的实现中，优化了高位运算的算法，通过 hashCode() 的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组 table 的 length 比较小的时候，也能保证考虑到高低位都参与到 HashCode 的计算中，同时不会有太大的开销。
在 JDK1.8 中通过 (n - 1) & hash 定位 key 在数组中位置，其中由于 table 的大小总是2的n次方，所以通过位与替代了取模（二者是等效的）大大提升了效率。
下面举例说明下，n为table的长度。
2. 存储实现 - put() 方法
下面是 put() 方法的流程图，结合流程图可以更好的理解源码
// 与 JDK 1.7 不同，JDK 1.8 将存储过程的实际处理逻辑放在 putVal() 方法中
public V put(K key, V value) {
// 对 key 进行二次 hash
return putVal(hash(key), key, value, false, true);
}
// onlyIfAbsent 为 true, 不修改已经存在的 value
// evict 为 false, 数组 table 处于 creation 模式
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;
// 根据 hash 值获得对应的数组索引 i，如果table[i]==null，则直接添加新节点
// 此时 p 为table[i] 的首元素
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//此时 table[i] 不为空，即发生了 hash 碰撞
else {
Node<K,V> e; K k;
// 如果根节点的 key 和 传入的 key 相同则在下一个 if 语句修改 value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断 table[i] 是否为 treeNode (红黑树)，如果是红黑树则在树中插入键值对
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 遍历 table[i] 的链表
for (int binCount = 0; ; ++binCount) {
// 要是下一个元素为空则插入一个新的节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 要是链表长度大于 8，则将链表转为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) t
treeifyBin(tab, hash);
break;
}
// 要是 key 已经存在则下一个 if 语句修改其 value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 在这里集中进行 value 修改，要是需要修改 value 则 e 肯定不为空
if (e != null) {
V oldValue = e.value;
// onlyIfAbsent 为 true 则不修改已经存在的 value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// HashMap 中为空，留给 LinkedHashMap 实现
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 要是当前元素的数量超过 threshold 则扩容
if (++size > threshold)
resize();
// HashMap 中为空，留给 LinkedHashMap 实现
afterNodeInsertion(evict);
return null;
}
3. 扩容实现 - resize() 方法
HashMap 对数组 table 是懒加载的，只有当第一次调用 put() 方法时才会调用 resize() 方法进行初始化。resize() 方法的主要功能有两个：
- 对数组 table 进行初始化，默认容量为16；
- 对数字 table 进行扩容，保证其 capacity 是上一次的两倍，而且始终为2的n次方。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 如果 table 没有初始化则为零，否则为数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
/*
* 扩容或初始化前的准备操作：设置 newCap 和 newThr
* 如果 table 已经初始化则进行扩容
* 否则根据初始化使用的构造函数进行相应的初始化准备操作
*/
// 初始化前 oldCap=0，oldCap>0 则表示已初始化
if (oldCap > 0) {
// oldCap > 0，此时 table 已经初始化，进行扩容操作
// 如果 oldCap 大于 2^30 则把 threshold 设为最大，不再对数组扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 容量扩大两倍后小于 MAXIMUM_CAPACITY 且 oldCap>16,则将threshold扩大两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 要是条件不成立 newThr=0
}
// 此时 oldCap=0 需要进行初始化的准备
else if (oldThr > 0)
// 此时 oldThr 被设置(即 threshold），new HashMap 时使用下面的构造函数
// HashMap(int initialCapacity)
// HashMap(int initialCapacity, float loadFactor)
newCap = oldThr;
else {
// threshold=0，对应构造方法 HashMap()
newCap = DEFAULT_INITIAL_CAPACITY; // 将 newCap 设置为默认值
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 对应构造函数
// HashMap(int initialCapacity)
// HashMap(int initialCapacity, float loadFactor)
// 或者在下面条件不成立时重新计算 newThr
// (newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY
float ft = (float)newCap * loadFactor;
// 因为使用的是指定的 nitialCapacity,所以需要对 newThr 进行判断处理
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 根据 newCap 创建新数组，和 设置新的 threshold
threshold = newThr;
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;
// 如果首元素后面没有元素则直接迁移到新数组
// 因为扩容后会与首元素发生 hash 碰撞的只能是其后面跟着的元素
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 {
/*
* 处理链表，扩容后 hash 不一定仍相同
* 假设容量从 16 增加到32
* 首元素和下一个元素 hash 前五位为 00001 和 10001
* 容量为16时，hash&(cap-1) 均为 0001
* 而容量为32时， hash&(cap-1) 则为 00001 和 10001
* 同时容量为16时， hash&cap 则为 00000 和 10000
* */
Node<K,V> loHead = null, loTail = null; // 低位 hash
Node<K,V> hiHead = null, hiTail = null; // 高位 hash
Node<K,V> next;
do {
next = e.next;
// 扩容时增加的那一位为零，hash 不变
// loHead 指向第一个元素，loTail 指向最后一个元素
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 扩容时增加的那一位为一，hash = hash + oldCap
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;
}
相关文章
