【3月6日】源码阅读日记（1）：HashMap

前言

首先，致敬下几位authors

@author  Doug Lea
@author  Josh Bloch
@author  Arthur van Hoff
@author  Neal Gafter

HashMap是Java程序员使用频率最高的用于映射(键值对)处理的数据类型。随着JDK（Java Developmet Kit）版本的更新，JDK1.8对HashMap底层的实现进行了优化，例如引入红黑树的数据结构和扩容的优化等。

1. HashMap概述

HashMap是基于哈希表的 Map 接口的实现，以key-value对的形式存储数据。

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

通过源码，我们知道，HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。

- HashMap 的实现不是同步的，这意味着它不是线程安全的。

- 它的key、value都可以为null。

上述两点是HashMap和Hashtable的最重要的区别。此外，HashMap中的映射不是有序的。

可以使用工具类Collections中的方法：Map m = Collections.synchronizedMap(new HashMap(…));来获取一个并发的hashmap。当遍历HashMap时，有另一个Thread试图修改hashmap，会立即终止迭代并抛出 ConcurrentModificationException ，即所谓的fail-fast策略。

初始容量和加载因子

在HashMap中，有两个参数会影响其性能：：“初始容量（initialCapacity）” 和 “加载因子（loadFactor）”。

容量 是哈希表中桶的数量，初始容量 只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

通过下面的源码可以看出，初始容量必须是2的平方，默认为16，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。

/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;

如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。 如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。

/**
* Increases the capacity of and internally reorganizes this
* hashtable, in order to accommodate and access its entries more
* efficiently.  This method is called automatically when the
* number of keys in the hashtable exceeds this hashtable's capacity
* and load factor.
* 增加散列表的容量并在内部重新组织，以便更有效地容纳和访问条目。
* 当散列表中的键数超过散列表的容量和加载因子的乘积时，将自动调用此方法。
* 使得 ：newCapacity = (oldCapacity << 1) + 1
*/

@SuppressWarnings("unchecked")
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;

// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1;
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
table = newMap;

for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;

int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}

HashMap的构造函数

1 参数：初始容量+加载因子

/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param  initialCapacity the initial capacity
* @param  loadFactor      the load factor
* @throws IllegalArgumentException if the initial capacity is negative
*         or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
//a. 初始容量小于零 非法
if (initialCapacity
4000
< 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//b.初始容量大于 MAXIMUM_CAPACITY，置为 MAXIMUM_CAPACITY。
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 加载因子小于零或者为null，非法
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}

2 参数 : 初始容量

/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param  initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
// 加载因子为默认值
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

3 参数：无

/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

4 参数：子Map

这里面用到了putMapEntries()方法，该方法用于重置Map的key-value。

/**
* Constructs a new <tt>HashMap</tt> with the same mappings as the
* specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
* default load factor (0.75) and an initial capacity sufficient to
* hold the mappings in the specified <tt>Map</tt>.
*
* @param   m the map whose mappings are to be placed in this map
* @throws  NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}

HashMap的API

void                 clear()
Object               clone()
boolean              containsKey(Object key)
boolean              containsValue(Object value)
Set<Entry<K, V>>     entrySet()
V                    get(Object key)
boolean              isEmpty()
Set<K>               keySet()
V                    put(K key, V value)
void                 putAll(Map<? extends K, ? extends V> map)
V                    remove(Object key)
int                  size()
Collection<V>        values()

2.源码解析

2.1 实现原理

在HashMap的实际实现时，其底层为bucket的数组(bucket=bin)。
为让Node分布更均匀，不至于扎堆集中到同一个bin中，通过key.hashCode()经位运算得一个h值，在利用此h值来计算数组下标index。据此index，在数组中定位到bucket，然后在bucket中进行查找或插入。bucket有list和tree两种形式：list式的node更小，但是可能导致bucket很深，遍历list时更耗时；treenode更大，但其能有效降低bucket的深度，能够更加快速的遍历bucket。在实际使用时，只有当map比较大时，才会采用tree式的bucket，以空间换时间。

//几个重要属性
transient Node<K,V>[] table;     //bucket的数组，即底层list的数组
transient int size;              //<key, value>对的数量，调用size()方法返回的就是这个量
transient int modCount;          //记录在迭代时，map被修改的次数，据此在并发环境下报告异常，用来实现fail-fast机制的。

2.2 hash的原理

HashMap最大的优点就是快。

首先看一下这个hash是如何出来的，上源码：

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

以上也就解释了为什么的HashMap是允许null的。且对于key来说，如果是null，返回的hash就是0，否则就返回 (h = key.hashCode()) ^ (h >>> 16)。

此过程调用了key.hashCode()方法，hashCode()是超类Object中定义的方法，返回对象的hash值，对此方法的常规协定有：

在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。

如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。

如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

此方法不同的类有具体的实现，以String中的为例，看看其hashCode()方法的说明：

String 对象的哈希码根据以下公式计算：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希值为 0。）选择31是因为它是一个奇素数，但是它已经成为了传统的选择。总体上来说，使用31的优势在于：

31是一个素数，相乘得到的结果更具有唯一性；

31还是一个奇数，因为偶数在乘法溢出时，信息会丢失，因为与2相乘等价于位移运算;

31还具备一个很好的性能，就是可以用位移和减法代替乘法运算：31*i == (i<<5)-i。

具体的实现如下：

// String 类的hashCode()
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;

for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}

那么底层上是如何保证相比于其他的数据储存方式，HashMap的速度更快的呢？这里以HashMap的的put()方法进行切入。下面上源码。

// put方法调用的final V putVal()
public V put(K key, V value) {
// 调用hash()方法计算出对应的hash指，再调用putVal
return putVal(hash(key), key, value, false, true);
}

/**
* 实现Map.put()的相关方法
*
* @param hash  key的hash值
* @param key 键
* @param value 需要put的值
* @param onlyIfAbsent 为真，不改变已有的值
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
* 为方便理解，理清如下量：
* tab ：  transient Node<K,V>[] table， 数组
* n： map的长度
* i： (n - 1) & hash计算出的索引
* p = tab[i]:在该索引上的元素
* k = p.key: 该索引元素的key
* e = p.next
*/
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为空或者table的长度为零，resize()一下，这里的resize()涉及到一系列策略，这里就不谈了。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;

// (n - 1) & hash 并运算，计算其在数组中的索引
// 如果该索引为null，则直接添加value
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 如果p的hash和key 均与 要put的相同，直接e=p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 否则，如果p为TreeNode
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
// p.next == null 的话直接加入
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;
}
}
// e不为null
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent为false 或者 e.value ==null 的时候，更新e的value；否则，不更新
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

我们特别关注一下在put()中的(n - 1) & hash，这个按位与的算法其实就是h%length求余，一般什么情况下利用该算法，典型的分组,例如怎么将100个数分组16组中，应用非常广泛。。为什么不直接用 hash 对 数组长度取模？因为除法运算效率低

2.3 Node

/**
* Basic hash bin node, used for most entries.  (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
// 利用静态内部类Node来封装<key-value>对数据，同时用next属性来构成list结构的bucket
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; }

// 基于位运算的hashCode()
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}

public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}

// 判断两个对象相等 当且仅当两个Entry的key和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;
}
}

从中，我们可以看出 Node 实际上就是一个单向链表。这也是为什么我们说HashMap是通过拉链法解决哈希冲突的。

Node 实现了Map.Entry 接口，即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。

一些方法的实现

clear()

clear() 的作用是清空HashMap。它是通过将所有的元素设为null来实现的。

public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}

containsKey()和get()

containsKey() 的作用是判断HashMap是否包含key。两者都调用了getNode()。

public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;                //使用h值来定位bucket
}
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}

public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}

final Node<K,V> getNode(int hash, Object key) {            //被get与contains调用的工具方法，输入的hash不是key.hashCode，而是上面提到的h值
Node<K,V>[] tab;
Node<K,V> first, e;
int n; K k;
//index = (table.length-1) & h ，定位到bucket
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {

if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))  //若这个bin中第一个元素即为所找就直接返回
return first;

if ((e = first.next) != null) {                                   //否则，就得遍历这个bucket来查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);     //bin为tree式的

do {                                                          //bin为list式的
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;                                             //在遍历bucket时得不断调用equals()方法
} while ((e = e.next) != null);
}

}
return null;
}

containValue()

基本也是把Value分为null和非nul进行讨论，即 if ((v = e.value) == value ||

(value != null && value.equals(v)))

public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}