Java源代码阅读——HashMap实现原理

一 概述

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

基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。

二 构造函数

static final int DEFAULT_INITIAL_CAPACITY = 16;//默认大小16

static final int MAXIMUM_CAPACITY = 1 << 30;//2的30次方

static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认装填因子0.75

transient Entry<K,V>[] table;

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)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);        table = new Entry[capacity];        useAltHashing = sun.misc.VM.isBooted() &&                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);        init();    }    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    public HashMap() {        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);    }

hash表的装填因子=表中填入记录数/表的长度。
分析第一个构造函数：

int capacity = 1;while (capacity < initialCapacity)    capacity <<= 1;

保证capacity的大小为大于且最接近initialCapacity的2的次幂。原因后续讨论。

三 indexFor()函数

static int indexFor(int h, int length) {     return h & (length-1);}

采用&运算寻找索引，先看indexFor()的使用：

final Entry<K,V> getEntry(Object key) {        int hash = (key == null) ? 0 : hash(key);        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 != null && key.equals(k))))                return e;        }        return null;}

hash()函数：

final int hash(Object k) {        int h = 0;        if (useAltHashing) {            if (k instanceof String) {                return sun.misc.Hashing.stringHash32((String) k);            }            h = hashSeed;        }        h ^= k.hashCode();        // 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); }

由上述调用逻辑可以看出，给定一个key寻找它所对应entry的过程为：

（1）计算hash(key)。

（2）计算indexFor(hash(key),table.length),即为该条目在table[]中的索引。

（3）遍历该索引上的链表找到==或equal key的entry返回。

四 capacity为何要是2的次方（个人理解）

（1）当capacity=2的次方时：h&(capacity-1)==h%capacity，例：

h=7,capacity=8        h%capacity=7,h&(7)=0111&0111=0111;

h=9,capacity=8        h%capacity=1,h&(7)=1001&0111=0001;

于是，可用位运算代替模运算大大加快运算速度。

（2）取capacity为2的次方能提高存储空间利用率，减少冲突。例：

h=9,capacity=8       h%capacity=1,h&(7)=1001&0111=0001;

h=8,capacity=8       h%capacity=0,h&(7)=1000&0111=0000;

h=9,capacity=7       h%capacity=2,h&(6)=1001&0110=0000;

h=8,capacity=7       h%capacity=1,h&(6)=1000&0110=0000;

由上可见当capacity为奇数时，capacity-1位偶数，其二进制最低为必为0，与h进行与运算后最低位必为0，意味着只有编号为偶数的index才有可能存储数据，浪费了存储空间，增加冲突概率；而capacity为2的n次方时，capacity-1的二进制最低位为1，进行&运算后最低位为0或1都有可能，不存在上述缺陷。

五 为什么不直接用hashcode()（个人理解）

hashcode()为32位，而capacity默认为16位，如果两个对象的hashcode（）后16位相同，与16位的capacity-1进行&后得到相同的结果，产生冲突，所以通过hash（）函数进行处理。

六 resize()

void resize(int newCapacity) {        Entry[] oldTable = table;        int oldCapacity = oldTable.length;        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }        Entry[] newTable = new Entry[newCapacity];        boolean oldAltHashing = useAltHashing;        useAltHashing |= sun.misc.VM.isBooted() &&                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);        boolean rehash = oldAltHashing ^ useAltHashing;        transfer(newTable, rehash);        table = newTable;        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);    }

（1）何时扩容（resize）?

当HashMap中的元素个数超过数组大小*loadFactor时。

（2）如何扩容？

容量变为原来的两倍，然后重新计算每个元素在数组中的位置，这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

七 Fail-Fast机制

HashMap不是线程安全的，如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException异常。判断是否修改了map是通过modCount（修改次数）域，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。

在迭代过程中，判断modCount和expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map。

一般来说，存在非同步的并发修改时不可能作出任何的保证。Fail-Fast尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。