JAVA源码剖析（容器篇）HashMap解析（JDK7）

Map集合：

HashMap底层结构示意图：

HashMap是一个“链表散列”，其底层是一个数组，数组里面的每一项都是一条单链表。

数组和链表中每一项存的都是一“Entry对象”，该对象内部拥有key（键值名），value（键值），next（指向下一个结点）等属性。

一、HashMap属性：

内部属性源码解析：

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认容器初始容量，出于hash计算时的优化的考虑，必为2^n，此处为16

    static final int MAXIMUM_CAPACITY = 1 << 30;// 默认最大容量

    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的负载因子，关系到容器何时扩容

    static final Entry<?,?>[] EMPTY_TABLE = {};//扩容之前的默认数组

    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;// 用来存储数据（单向链表）的数组，长度就是容器长度即2^n

    transient int size;// 当前map的key-value映射数

    int threshold;// 下一次扩容的大小（第一次创建空hashmap时，会上传一个该值，用于下一次创建table时设置大小）

    final float loadFactor;// 自定义的负载因子，关系到容器何时扩容

    transient int modCount;// Hash表结构性修改次数，用于实现迭代器快速失败行为

    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;//容量阈值的默认大小

    transient int hashSeed = 0;//该值在计算hash值时会用到，大小与table容量有关，由于初始table为空，所以此值初始也为空

二、HashMap构造：

构造函数poublic源码解析：

    //生成空hashmap时指定容量大小和负载因子
    public HashMap(int initialCapacity, float loadFactor) {

        if (initialCapacity < 0)//初始容量大小不能小于0
            throw new IllegalArgumentException("Illegal initial capacity: " +
                    initialCapacity);

        if (initialCapacity > MAXIMUM_CAPACITY)//保证初始容量不大于默认的最大容量
            initialCapacity = MAXIMUM_CAPACITY;

        if (loadFactor <= 0 || Float.isNaN(loadFactor))//负载因子不能小于0，且只能为数字
            throw new IllegalArgumentException("Illegal load factor: " +
                    loadFactor);

        this.loadFactor = loadFactor;//设置负载因子

        threshold = initialCapacity;//设置下次创建数组的大小。此时因为建的是个空map，并不会立刻通过该值初始化数组，所以这个初始化大小值会先存起来，当以后put数据后，再根据该值创建初始数组的大小

        init();//进行一些必要的初始化，但在hashmap中没有实现，init()只在LinkedHashMap中有实现
    }

    //生成空hashmap时只指定初始容量大小，负载因子使用默认值
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    //生成空hashmap时，初始容量和负载因子都是用默认值
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    //构造hashmap时传入一个map，负载因子使用默认值，初始容量与传入的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);

        inflateTable(threshold);//对table扩容（新建一个table）

        putAllForCreate(m);//将指定map的键值对添加到当前map中
    }

相关private、friendly源码解析：

    //将指定map的键值对添加到当前map中
    private void putAllForCreate(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())//利用foreach迭代出传入map里的每一项entry对象
            putForCreate(e.getKey(), e.getValue());//调用私有方法存入该entry。（该私有put与public的put的主要区别是，该私有put不会扩容table（因为之前已经扩过了），也不会增加modCount）
    }

    //存入键值对
    private void putForCreate(K key, V value) {

        int hash = null == key ? 0 : hash(key);//根据key值生成hash值

        int i = indexFor(hash, table.length);//根据hash值生成数组下标索引

        //根据新存入值的下标，查询现有数组中该下标里是否有元素，如果有元素，由于该元素一定是以链表的形式存储的，则将插入元素的key与查询链表里的每一项元素的key进行比对
        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(hash, key, value, i);//在指定索引处的链表上创建该键值对
    }

    //在table数组的某一项中，创建单向链表的表头
    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对象。key-value实际上就是被存成了这种Entry对象
    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;//键值名
        V value;//键值
        Entry<K,V> next;//指向单向链表中的下一个entry对象
        int hash;//hash值

        //创建Entry对象时的构造函数
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        //获取entry的key
        public final K getKey() {
            return key;
        }

        //获取entry的value
        public final V getValue() {
            return value;
        }

        //用新value覆盖旧value，并返回旧value
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        //如果传入的是个Entry对象，则判断其key和value是否相同,相等则返回true
        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        //key与value的hashcode()做^运算
        public final int hashCode() {
            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

        //每当相同key的value被覆盖时被调用一次，HashMap的子类LinkedHashMap中实现了这个方法
        void recordAccess(HashMap<K,V> m) {
        }

        //每移除一个entry就调用一次
        void recordRemoval(HashMap<K,V> m) {
        }
    }

相关说明：

1、从源码可看出构造函数主要是负责在构造时指定“初始容量”和“负载因子”。

2、如果此时创建的是一个空map，则并不会直接创建其内部table数组，而是等到有数据添加进来后再创建。

但如果此时是根据传入的新map来构建此hashmap，则会先创建一个空hashmap，再根据初始化容量创建一个table数组，之后再将传入的map里的数组存入刚刚创建的table中。

3、关于负载因子（loadFactor），表示当前容量达到总容量的什么程度时再扩容。

如，loadFactor为0.75，且设置hashmap最大容量是16。当当前的数据量达到12时（16*0.75=12），就会进行扩容。同理，如果loadFactor为1，则当前的数据容量达到16时才会扩容。

4、“初始容量”在设置时不需要设置为2^n的形式，但在使用该值扩容（创建数组）时，就会查找“大于该值的最小2^n”。

三、HashMap存储：

相关public源码解析：

    //向hashmap存入一个键值对，如果该key已经存在，则覆盖该key的内容
    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {//如果此时数组为空，数组为空，则新建数组（扩容数组）
            inflateTable(threshold);
        }

        if (key == null)//hashmap中允许key为null，如果key为null，则对value的存储位置特殊处理
            return putForNullKey(value);

        int hash = hash(key);//根据key值，生成hash值

        int i = indexFor(hash, table.length);//根据hash值找到该值在table数组中的下标索引

        //根据新存入值的下标，查询现有数组中该下标里是否有元素，如果有元素，由于该元素一定是以链表的形式存储的，则将插入元素的key与查询链表里的每一项元素的key进行比对
        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))) {//如果新插入元素的key与链表中元素的key的“equals()与hashCode()”都相等，则覆盖value
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;//该hashmap的操作次数+1，与迭代器迭代有关

        addEntry(hash, key, value, i);//运行此方法表示该key值是新key，所以将存入的键值对变成一个“Entry对象”存入数组。

        return null;
    }

    //将指定map中的元素存入此hashmap
    public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();//传入map的key-value映射数量

        if (numKeysToBeAdded == 0)//传入map中的映射数量为0则不存
            return;

        if (table == EMPTY_TABLE) {//判断当前hashmap中是否有初始table数组，没有则创建（扩容）初始table
            inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
        }

        if (numKeysToBeAdded > threshold) {//传入map的key-value映射数量如果大于当前的“扩容大小”，则判断是否扩容
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)//与hashmap容量默认最大值比较，不能大于最大值
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)//如果当前数组长度小于targetCapacity，则扩大一个“2次方”
                newCapacity <<= 1;//按位运算，相当于扩大了一个平方
            if (newCapacity > table.length)//如果newCapacity扩大完后大于了当前数组的长度，则重新扩容数组
                resize(newCapacity);
        }

        //foreach传入的map，将里面的每个entry对象存入此map
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

相关private、friendly源码解析：

相关说明：

四、HashMap提取：

五、HashMap遍历：

六、HashMap线程相关：

七、HashMap其他注意事项：

1、只有JDK7之前是这一套底层结构，目前最新的JDK8中HashMap当同一个hash值的节点数大于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树。