【java集合】HashMap源码解析

HashMap是一种哈希表的数据结构的实现，也是java中常用的集合。HashMap的特性归纳如下：

特性	值
是否顺序存储	非顺序
是否可重复存储	key值不可以，value值可以
是否可存储null	可以
是否线程安全	非线程安全

HashMap的属性

首先列举一下HashMap主要属性，方便大家理解和本文的说明：

属性	说明
table	非常重要的属性，HashMap的原理就是数组+链表，这个就是数组
size	存储元素的总数
threshold	临界值，当元素数量大于thresholdthreshold，会进行扩容操作
loadFactor	可以调节扩容的频率,默认是0.75,一般用默认值就可以
modCount	被修改的次数，可以检查迭代过程中是否被修改
hashSeed	帮助生成hash值，一般为0

创建一个HashMap

        /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

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

这里列举了最常用的2个构造方法，方法1和方法2的区别是否指定初始化的容量。如果我们在使用时知道大致的数据量，可以选择方法2，这样可以提高程序的运行效率。在默认情况下，HashMap的初始容量是16，当HashMap存储的元素数量超过capacity * loadFactor时，会自动进行扩容，具体会在下面进行分析。

put方法

先分析一下HashMap的put(K key, V value)方法

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        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;
    }

第2-3行，判断table是否是空，为空的话进行初始化操作，主要是设置capacity，threshold，table。
第7行，取key对应的hash值，看一下源码：

    final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        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);
    }

不同版本的jdk，代码都有不同，但是原理基本相识。保障hash的均匀分布，尽量减少碰撞，以提高效率。这边主要对于高位和低位进行移位处理以及异或。

第8行根据，hash值计算在数组所在的索引位置，具体实现代就一行：return h & (length-1); 简单粗暴高效。

第9-17行，根据上面计算出的索引，再对索引下的key进行遍历，对于已有的key，对其value值进行更新。
第20行，如果是之前没有put过的key，则进行新增操作。

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

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

首先判断，是否达到临界值，大于等于临界值时进行扩容，每次扩容一倍。扩容的具体方法看第3行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];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

resize方法做了这些事情：
1.新建一个存放数据的数组，上面也说了数组的容量是之前的2倍
2.遍历旧的数组的数据，对于数据重新计算在新数组的index，并且放入新数组
3.设置新的临界值
所以一次扩容的消耗是挺高的，能在初始化的时候设置合适的容量，对于提高效率是有帮助的。
在回到addEntry方法的最后一行，createEntry方法：

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

取出数组对应索引的Entry，新的Entry设为表头。

HashMap底层是采用了数组+链表的数据结构，先计算key的hash值作为数组的索引，相同索引的用链表相互关联。

get方法

相对于put方法，get方法简单许多

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }

先判断key是否为null,是的话按数组index=0来取数据。
key！=null的话执行到第4行：

   final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        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;
    }

先计算key对应的索引，再遍历索引存储的链表，直到碰到key值相等的或者返回null。

remove方法

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

remove方法和get有些类似，找到对应的key和value，并从链表中去除。

总结

1.HashMap底层是采用了数组+链表（jdk1.8又引入红黑树）的数据结构
2.HashMap是非线程安全的
3.初始化的时候设置合适的容量，对于提高效率是有帮助的,当然如果你实在不知道该设置什么，可以使用默认。