HashMap 源码解析

HashMap 是键值对存储，且键值唯一，链表与数组混合结构的一种数据结构，因其高速查询存储效率而使用效率高，以下是其源码解析

构造参数

    // 默认容量
    static final int DEFAULT_INITIAL_CAPACITY = 4;
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //默认载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    static final HashMapEntry<?,?>[] EMPTY_TABLE = {};
    //存储数据的数据，需要时扩容，长度为2的倍数
    transient HashMapEntry<K,V>[] table = (HashMapEntry<K,V>[]) EMPTY_TABLE;
    //当前容量
    transient int size;
    //容量阈值，即存储一定的数据后，进行扩容
    int threshold;
    //使用的加载因子，默认为DEFAULT_LOAD_FACTOR
    final float loadFactor = DEFAULT_LOAD_FACTOR;
    //数据结构变动次数，如添加、删除时的变动
    transient int modCount;

参数中要注意的是加载因子，如源码注释所说，加载因子其实是HashMap在时间和空间上的权衡，加载因子越大，空间利用率越大而查询等速率越低；反之加载因子越小，查询速率越高，占用空间也就越多。这与HashMap的结构有关。这里先看看HashMap的结构

数据在存储的时候，会通过hash函数获得在数组table上的地址，也就是说，有可能使得多个数据在table上的地址是相同的，当这种情况出现时，需要访问样的位置，会降低访问的效率。 因此，加载因子越低，或者hash函数越理想，就越能让数据均匀地分布在table上。 具体的访问方式在后面会有

构造

public HashMap(int initialCapacity, float loadFactor) 
public HashMap(int initialCapacity)
public HashMap()
public HashMap(Map<? extends K, ? extends V> m)

四种构造方式，构造时会做容量检查，不做说明

访问操作

首先看插入数据put()

public V put(K key, V value) {
        //检查table，为空将其初始化
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //将key为null的键值对放到相应位置
        if (key == null)
            return putForNullKey(value);
        //获取hash值
        int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
        //通过hash值定位在table上的位置
        int i = indexFor(hash, table.length);


        for (HashMapEntry<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++;
        // 插入新的HashMapEntry
        addEntry(hash, key, value, i);
        return null;
    }

put()并不难理解，但是有需要看的地方，首先是inflateTable()，它会将table初始化，代码很简单，如下

private void inflateTable(int toSize) {
        // 容量为2的位数
        int capacity = roundUpToPowerOf2(toSize);
        // 容量阈值
        float thresholdFloat = capacity * loadFactor;
        if (thresholdFloat > MAXIMUM_CAPACITY + 1) {
            thresholdFloat = MAXIMUM_CAPACITY + 1;
        }
        threshold = (int) thresholdFloat;
        table = new HashMapEntry[capacity];
    }

再来是indexFor(), 通过table长度与hash值得与操作获得在table上的位置

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

然后，接下来的代码就没那么清晰了，因为关键的HashMapEntry还不知道是什么，那么有必要先看一下HashMapEntry

HashMapEntry

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

        ......
 }

首先，HashMapEntry继承Map.Entry, 然后存有一个key和value， 并且指向下一个HashMapEntry的next， 这是典型的链式结构，也就是说put进来的键值对会封装成HashMapEntry，将其以链表的形式存储于数组table里。

返回去看put(), put()通过indexFor获得了数据（也就是键值对将会成为HashMapEntry），在table上的位置，然后便利该位置上的HashMapEntry链表，如果要插入的数据的hash值与当前访问到的HashMapEntry的hash值相等并且key值也相等，说明该key已经被使用，则此put()操作实际应该理解为更新，回去更新此key的value。如果遍历完链表，说明key没有被使用，理解为在当前table的位置插入一个新的HashMapEntry，代码会运行到addEntry()

HashMapEntry的添加

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //扩容
            resize(2 * table.length);
            hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

addEntry会先检查容量是否超过阈值，如果超过了就进行扩容，然后再通过createEntry()进行HashMapEntry的创建添加。

void resize(int newCapacity) {
        HashMapEntry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        HashMapEntry[] newTable = new HashMapEntry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

void transfer(HashMapEntry[] newTable) {
        int newCapacity = newTable.length;
        for (HashMapEntry<K,V> e : table) {
            while(null != e) {
                HashMapEntry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }

扩容代码不难，不做解释

void createEntry(int hash, K key, V value, int bucketIndex) {
        HashMapEntry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
        size++;
    }

HashMapEntry(int h, K k, V v, HashMapEntry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

在添加HashMapEntry时，会让e指向table[bucketIndex]，然后table[bucketIndex]创建新的HashMapEntry，新的HashMapEntry指向e，也就是说，HashMapEntry的添加操作将新节点加到链表头。现在，put()的整个操作就清晰了，数据结构也是如此，如下图：

看完了put() , 再看remove()操作

HashMapEntry的移除

    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.getValue());
    }

 final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {
            return null;
        }
        //获得hash值
        int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
        //定位table
        int i = indexFor(hash, table.length);
        HashMapEntry<K,V> prev = table[i];
        HashMapEntry<K,V> e = prev;

        while (e != null) {
            HashMapEntry<K,V> next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;
                //在链表头
                if (prev == e)
                    table[i] = next;
                //其他位置
                else
                    prev.next = next;
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

通过key来移除HashMapEntry，首先当然是获取hash值，然后定位在table上的位置，接着遍历此位置上的链表，根据HashMapEntry在链表的不同位置坐相应处理。

其他的操作如containsValue()也大同小异，都是先获取hash值，定位在table上的位置，遍历链表。在此就不多赘述了。

总结
1、HashMap以数组和链表混合作为数据结构，存储粒度为HashMapEntry
2、HashMap加载因子用以权衡在空间和时间上的权重

此处先做了解HashMap的基本构造，往后会做更新