java.util.HashMap源码解析

1.java集合框架图

2.所属包

package java.util;

3.继承与实现关系

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

4.准备知识

HashMap是基于哈希表的非同步的实现，不保证映射的顺序永久不变，可以键值对都为null。哈希表的核心就是根据元素求位置。而多个元素可能出现相同的位置，那么就叫冲突。解决冲突的常用方式：链地址法：将多个值的不同的哈希结果（哈希值）用数组进行存储，然后将产生相同哈希值的元素，以单向链表的形式进行存储。所以拉链法的套路就是数组+单链表。第二种解决方式是线性探测法：将多个值余上表长度，如果多个值产生相同的哈希值，那么就依次往下寻找位置，直到不冲突为止。线性探测法致命的缺点就是当数据量上来时，就会频繁的进行碰撞冲突，然后找到位置比较费劲。

5.属性

/**     * 默认初始化容量为16     */    static final int DEFAULT_INITIAL_CAPACITY = 16;    /**     * 最大容量，必须是2的n次幂     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * 默认加载因子     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;    /**     * 存储数据的Entry数组，是存储实体的数组，长度是2的幂     */    transient Entry<K,V>[] table;    /**     * 映射键值对的个数，也是数组中元素的个数     */    transient int size;    /**     * 临界值，当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量     */    int threshold;    /**     * 哈希表的加载因子     */    final float loadFactor;    /**     * 被修改的次数     */    transient int modCount;

6.HashMap中链地址的单链表结构

static class Entry<K,V> implements Map.Entry<K,V> {        final K key;        V value;        Entry<K,V> next;//指向下一个相同hash值得元素        int hash;//哈希值        Entry(int h, K k, V v, Entry<K,V> n) {            value = v;            next = n;            key = k;            hash = h;        }        .............        .............}

7.构造方法

/**构造方法1：     * 初始化一个Entry数组，数组大小为2的n次幂     */    public HashMap(int initialCapacity, float loadFactor) {//如果初始化容量小于0，报非法参数异常        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);//如果初始化容量大于最大容量，那么将最大容量作为初始化容量        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;//如果加载因子小于0或者为非小数，那么就报非法参数异常        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        // 让容量以2的n次幂递增，这样保证了容量大小为偶数        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;        this.loadFactor = loadFactor;        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//以定义的容量capacity初始化Entry数组        table = new Entry[capacity];        useAltHashing = sun.misc.VM.isBooted() &&                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);        init();    }

/**构造方法2     * 使用默认的加载因子和初始化容量构造HashMap     */    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }

/**构造方法3     * 使用默认的初始化容量16，和默认的加载因子0.75构造HashMap     */    public HashMap() {        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);    }

/**构造方法4     * 构造一个映射关系与指定 Map 相同的 HashMap。 * 所创建的 HashMap 具有默认的加载因子 (0.75) 和足以容纳指定 Map 中映射关系的初始容量。      */    public HashMap(Map<? extends K, ? extends V> m) {        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);        putAllForCreate(m);    }       //遍历m获取值，放入哈希表    private void putAllForCreate(Map<? extends K, ? extends V> m) {        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())            putForCreate(e.getKey(), e.getValue());    }

private void putForCreate(K key, V value) {//如果键为空，hash值为0，如果键不为空，那么就通过键来生成hash值        int hash = null == key ? 0 : hash(key);//通过hash值来获取索引        int i = indexFor(hash, table.length);        /**         * 通过索引查找到table中的Entry节点，进行遍历单链表中的Entry节点。 * 如果出现了该索引对应hash值和键都相同的，那么就直接退出该方法。         */        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash &&                ((k = e.key) == key || (key != null && key.equals(k)))) {                e.value = value;                return;            }        }//否则就执行createEntry方法创建该桶        createEntry(hash, key, value, i);    }

8.方法

createEntry：

void createEntry(int hash, K key, V value, int bucketIndex) {//根据索引得出对应定义的Entry类型对象e        Entry<K,V> e = table[bucketIndex];//将e进行初始化哈希值、键、值，以及单链表指向的下一个节点e        table[bucketIndex] = new Entry<>(hash, key, value, e);        size++;    }

如果没有相同的hash值和键，那么就会采用上面的方法来创建Entry。就是使用构造器初始化Entry。

hash：

/**     * 根据键来获取对应的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();        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

使用键来获取对应的hash值，方法首先是进行了hashcode方法先散列一次，然后再进行右移和异或运算。

indexFor：

/**     * 返回hash值对应的索引。     */    static int indexFor(int h, int length) {        return h & (length-1);    }

在我们自己实现哈希表的时候，常常会采用取%的方式来进行散列，将余数作为散列码。但是java采用的是二进制与运算来取hash值。由于length为2的n次幂，所以其减一为奇数，那么转化为二进制，末位肯定是1。如果hash值h为奇数，那么h与length的与运算，返回索引的二进制末位为1.如果hash值h为偶数，那么h与length的与运算，返回索引的二进制末位为0。这就相当于取模运算了，但是与位运算比取模速度快很多。并且这样也可以保证数组的下标不会越界。是一个很棒的选择。由于与运算加上前面hash（key）函数的高位运算，就减少了碰撞。这样就保证了hash值分布比较均匀并且冲突的概率很低。并且只有在值相同时，才会对应数组中的相同位置Entry，然后以next的形式构成链表。

put方法：

/**     * 将指定值与此映射中指定的键关联。如果映射以前包含了键的映射，则替换旧值。     */    public V put(K key, V value) {        if (key == null)            return putForNullKey(value);//通过键获取hash值        int hash = hash(key);//通过hash值获取下标索引        int i = indexFor(hash, table.length);/*** 如果hash值和键都相同的话，那么就返回对应的旧的值。* 然后新值覆盖旧值。*/        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;    }

 /**     * 如果当键为空时且键相同，就查找表，如果值也相同，那么就返回旧值。 * 否则就添加新值且返回空     */    private V putForNullKey(V value) {        for (Entry<K,V> e = table[0]; e != null; e = e.next) {            if (e.key == null) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(0, null, value, 0);        return null;    }

addEntry方法：

/**     * 添加新的值     */    void addEntry(int hash, K key, V value, int bucketIndex) {/**  * 映射键值对数目超出了临界值的情况。         * 创建新表容量为原来旧表的二倍，将旧表元素转移到新表。 * 然后通过键生成新的hash值。 * 然后通过新的hash值获取对应的下标索引*/        if ((size >= threshold) && (null != table[bucketIndex])) {            resize(2 * table.length);            hash = (null != key) ? hash(key) : 0;            bucketIndex = indexFor(hash, table.length);        }//通过新的hash值、键、值、下标索引来以构造器的方式创建Entry        createEntry(hash, key, value, bucketIndex);    }

resize方法：

/**     * 就是将HashMap就行扩容操作     */    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);//然后更新当前的Entry数组，也可以说更新桶        table = newTable;//然后临界值也由新容量进行调整        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);    }

transfer方法：

/**     * 将旧表中的元素都转移到新表中     */    void transfer(Entry[] newTable, boolean rehash) {//获取新表的容量        int newCapacity = newTable.length;//遍历旧表中的Entry，然后通过旧表中的Entry创建新表的Entry。        for (Entry<K,V> e : table) {            while(null != e) {                Entry<K,V> next = e.next;//如果需要就重新通过键生成hash值                if (rehash) {                    e.hash = null == e.key ? 0 : hash(e.key);                }//通过hash值获取下标索引                int i = indexFor(e.hash, newCapacity);//设置当前Entry节点e指向的下一个节点Entry值为newTable[i]                e.next = newTable[i];//将遍历到的Entry作为新表下标索引对应的值                newTable[i] = e;//单链表循环的条件                e = next;            }        }    }

可以看到为了转移元素，使用旧的值生成hash值，再重新计算下标索引的位置，用了两层循环，时间复杂度增加了数量级，非常消耗性能。所以如果我们已知了需要的空间，那么就会减少不必要的因为超出的原因产生的扩容操作，减少了性能的消耗。

get方法：

/**     * 当键为空的时候，就遍历桶，然后找出键为空对应的值。 * 如果键不为空，就通过键生成hash值，再通过hash值生成下标索引，遍历下标索引对应的Entry单链表，获取到hash值和键相同的对应的元素 * 如果查询到的Entry为null那么就返回null，否则返回Entry对应的值。     */    public V get(Object key) {        if (key == null)            return getForNullKey();        Entry<K,V> entry = getEntry(key);        return null == entry ? null : entry.getValue();    }/**     * Returns the entry associated with the specified key in the     * HashMap.  Returns null if the HashMap contains no mapping     * for the key.     */    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;    }

9.巧妙的设计

<1>.通过的表长为2的n次幂

<2>.可以通过键获取hash值（hash方法）

<3>.可以通过hash值来获取下标索引（indexFor方法）

<4>.通过下标索引找到对应的Entry值，通过Entry值可以单链表的遍历方式或者hash值方式来找到哪些冲突的值。

<5>.put操作，如果旧空间不够，那么就扩容为原来的2倍，然后将旧元素移动到新空间。

10.参考文章

深入Java集合学习系列：HashMap的实现原理

通过分析 JDK 源代码研究 Hash 存储机制

-----------------------------该源码为jdk1.7版本的