Java7源码浅析——对HashMap的理解

HashMap作为Java的集合框架成员中的一种，平时开发用得也不少了，心血来潮想着去看看它的具体实现，于是就去研究了一下Java7的对于HashMap部分的源码，同时也翻阅了一些网上优秀的博客，受益匪浅，决定记录一下自己对于HashMap的理解。

一、HashMap的定义

HashMap基于HashTable的Map接口实现（实现了Map接口，继承AbstractMap），此实现提供所有可选的映射操作，并且允许NULL值和NULL键（HashMap类大致相当于HashTable类，但它是非同步的，而且允许空值。）此类不保证映射顺序，特别是它不保证该顺序保持恒定一段时间。

一个HashMap的实例有两个影响其性能的参数：初始容量（capacity默认是16）和加载因子（load factor默认是0.75），通常缺省的加载因子较好地实现了时间和空间的均衡，增大加载因子虽然说可以节省空间但相对地会增加对应的查找成本，这样会影响HashMap的get和put操作。加载因子表示Hash表中的元素的填满程度，填充得越多对应的查找的时候发生冲突的机率就越大，查找的成本就越高。

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

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

/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;

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

二、HashMap的数据结构

Java基本的数据结构无非就是线性表、链表、哈希表。HashMap就是基于哈希表实现的Map：



从图中我们也可以看出其实它就是线性表和链表的结合，下面是HashMap的构造函数：

/**
* 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) {
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);

// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;

this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}

通过查看源码我们可以看到每次初始化一个HashMap都会去初始化一个table

/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
transient Entry[] table;

Entry是HashMap里面的一个静态内部类：

static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;

/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}

Entry是table中的元素，而Entry中又包含了key-value键值对，这样就可以通过key去指向下一个value，这就形成了链表，这样就可以呈现出如上图所示的数据结构了。

三、HashMap的存取实现

1、存储

我们先看源码：

/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
*         <tt>null</tt> if there was no mapping for <tt>key</tt>.
*         (A <tt>null</tt> return can also indicate that the map
*         previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
addEntry(hash, key, value, i);
return null;
}

通过源码，我们可以大概知道HashMap存储的过程：

（1）先判断key是否为null，如果是null，返回putForNullKey方法；

（2）如果不为空，则先计算hash值（根据key的hashCode方法得出对应的hashCode值，再通过hash方法自己重新计算，这里看源代码）

/**
* Applies a supplemental hash function to a given hashCode, which
* defends against poor quality hash functions.  This is critical
* because HashMap uses power-of-two length hash tables, that
* otherwise encounter collisions for hashCodes that do not differ
* in lower bits. Note: Null keys always map to hash 0, thus index 0.
*/
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}

这个算法是个纯粹的数学运算了，此算法加入高位计算，防止低位不变、高位变化时造成的Hash冲突。这是HashMap里面的精华所在，Java8已经做了简化：

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

具体原理解释起来好长，反正就是很精妙，到现在我还是似懂非懂。。。。详情见这里JDK 源码中 HashMap 的 hash 方法原理

（3）得到计算出来的hash值之后，将hash值和表的长度进行逻辑与操作

/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}

返回一个index下标（可以理解成要见元素放进去的位置）

（4）拿到下标，table[index]拿到这个位置上的元素e，看看这个元素，如果为null直接跳出循环addEntry；如果不为null则迭代判断是否存在相同的key，如果存在就会覆盖原来的，这就可以解释为什么HashMap里面没有相同的key了，因为它对没对key进行处理。

（5）最后是addEntry这个方法

/**
* Adds a new entry with the specified key, value and hash code to
* the specified bucket.  It is the responsibility of this
* method to resize the table if appropriate.
*
* Subclass overrides this to alter the behavior of put method.
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}

把原来table[index]位置上的Entry赋值给新的Entry的next，也就是说将新的Entry放入链头。

（6）如果容量不够大，那就扩容resize。

2、读取

读取就比较好理解了，找到对应的key就能拿到value了，先看看源代码：

public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}

在整个HashMap的实现中，它在底层用一个Entry数组去存储所有的key和value的值，找的时候判断一下hash值和key的值相等就可以返回value了。不同的东西放在不同的地方，找起来只要知道位置就能减少查找时间。

3、Fast-Fail机制

在HashMap里面定义了一个迭代器。大家都知道HashMap不是线程安全的，如果在迭代器的过程中别的线程修改了HashMap，将会抛出ConcurrentModificationException。在HashMap里定义了一个修改次数modCount，在初始化迭代器的时候会把这个modCount赋值给迭代器的expectedModCount。如源码所示：

private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next;        // next entry to return
int expectedModCount;   // For fast-fail
int index;              // current slot
Entry<K,V> current;     // current entry

HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
}

然后再迭代的过程中会判断：

if (modCount != expectedModCount)
throw new ConcurrentModificationException();

到这里就是我对HashMap的所有理解了，有说得不对的地方还望给我指出。