JDK1.7 hashMap源码分析

了解HashMap原理之前先了解一下几种数据结构：

1、数组：采用一段连续的内存空间来存储数据。对于指定下标的查找，时间复杂度为O(1)，对于给定元素的查找，需要遍历整个数据，时间复杂度为O(n)。但对于有序

　　数组的查找，可用二分查找法，时间复杂度为O(logn)，对于一般的插入删除操作，涉及到数组元素的移动，其平均时间复杂度为O(n)。

2、哈希表：也叫散列表，用的是数组支持元素下标随机访问的特性，将键值映射为数组的下标进行元素的查找。所以哈希表就是数组的一种扩展，将键值映射为元素下标的函数叫做

　　哈希函数，哈希函数运算得到的结果叫做哈希值。哈希函数的设计至关重要，好的哈希函数会尽可能地保证计算简单和散列地址分布均匀。

　　哈希冲突（也叫哈希碰撞）：不同的键值通过哈希函数运算得到相同的哈希值，解决哈希冲突的方式有开放寻址法和链表法，ThreadLocalMap由于其元素个数较少，

　　采用的是开放寻址法，而HashMap采用的是链表法来解决哈希冲突，即所有散列值相同的元素都放在相同槽对应的链表中（也就是数组+链表的方式）

3、链表：链表使用内存中不连续的内存块进行数组的存储，其不支持随机访问，每次元素的查找都要遍历整个链表，时间复杂度为O(n)。

　　HashMap是由数组+链表构成的，即存放链表的数组，数组是HashMap的主体，链表则是为了解决哈希碰撞而存在的，如果定位到的数组不包含链表（当前的entry指向为null），那么对于查找，删除等操作，时间复杂度仅为O(1)，如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先需要遍历链表，存在相同的key则覆盖value，否则新增；对于查找操作，也是一样需要遍历整个链表，然后通过key对象的equals方法逐一比对，时间复杂度也为O(n)。所以，HashMap中链表出现的越少，长度越短，性能才越好，这也是HashMap设置阀值即扩容的原因。

HashMap的主干是一个Entry数组，Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。

    /**
     * An empty table instance to share when the table is not inflated.
     */
    static final Entry<?,?>[] EMPTY_TABLE = {};
    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

Entry是HashMap中的一个静态内部类

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

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

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

        public final int hashCode() {
            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
        }

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

        /**
         * This method is invoked whenever the value in an entry is
         * overwritten by an invocation of put(k,v) for a key k that's already
         * in the HashMap.
         */
        void recordAccess(HashMap<K,V> m) {
        }

        /**
         * This method is invoked whenever the entry is
         * removed from the table.
         */
        void recordRemoval(HashMap<K,V> m) {
        }
    }

其他属性：

    /**
     * The default initial capacity - MUST be a power of two.处理容量，2的4次方，16，扩容后的容量必须是2的次方
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.　　最大容量，2的30次方
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.　　默认负载因子，0.75f
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
        /**
     * The next size value at which to resize (capacity * load factor).
     * @serial
     */
    // If table == EMPTY_TABLE then this is the initial capacity at which the
    // table will be created when inflated.
    int threshold;　　扩容阀值

构造函数：

    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);
　　　　
        this.loadFactor = loadFactor;
　　　　 // 目前扩容阀值等于初始容量，在真正构建数组的时候，其值为 容量*负载因子
        threshold = initialCapacity;
        init();
    }

可以看到，在进行put操作的时候才真正构建table数组

put方法：

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
　　　　　// 根据key计算哈希值
        int hash = hash(key);
　　　　　// 根据哈希值和数据长度计算数据下标
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
　　　　　　　// 哈希值相同再比较key是否相同，相同的话值替换，否则将这个槽转成链表
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;　　// fast-fail，迭代时响应快速失败，还未添加元素就进行modCount++,将为后续留下很多隐患
        addEntry(hash, key, value, i);　　// 添加元素，注意最后一个参数i是table数组的下标
        return null;
    }

inflateTable：

    /**
     * Inflates the table.
     */
    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize，寻找大于等于toSize的最小的2的次幂，如果toSize=13，则capacity=16；toSize=16,capacity=16
　　　　 // toSize=28,capacity=32;也就是说，当你设置了HashMap的初始容量initCapacity时，并不是存储的数据达到设置的初始容量initCapacity*loadFactor时就扩容
　　　　 // 而是到了capacity = roundUpToPowerOf2(initCapacity)，capacity *loadFactor时才会扩容。
        int capacity = roundUpToPowerOf2(toSize); // 返回小于(toSize- 1) *2的最接近的2的次幂 ，如果toSize=1，则capacity=1，所以如果将initcapacity设为的话，第一次put不会扩容  

        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }

hash方法：

    final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
　　　　// 先取key的hashCode再和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);
    }

indexFor：

    /**
     * Returns index for hash code h.　　返回数组下标
     */
    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);　　保证获取的index一定在数组范围内
    }

所以最终存储位置的获取流程是这样的：

key--hashCode()-->hashCode--hash()-->h--indexFor()、h&(length-1)-->存储下标

addEntry：

　　 transient int size;　　// Entry数组实际大小
    void addEntry(int hash, K key, V value, int bucketIndex) {
　　　　　// 添加新元素前先判断数组的大小是否大于等于阀值，如果是且数组下标位置已经存在元素则对数组进行扩容，并对新的key重新根据新的数组长度计算下标
        if ((size >= threshold) && (null != table[bucketIndex])) {
　　　　　　  // 数组长度扩容为之前的2倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
　　　　
        createEntry(hash, key, value, bucketIndex);
    }
　　// 将新的key-value存入Entry数组并size自增1
    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++;
    }

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

transfer：

哈希桶内的元素被逆序排列到新表中

    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
　　　　 // 遍历旧数组得到每一个key再根据新数组的长度重新计算下标存进去，如果是一个链表，则链表中的每个键值对也都要重新hash计算索引
        for (Entry<K,V> e : table) {
　　　　　　// 如果此slot上存在元素，则进行遍历，直到e==null，退出循环
            while(null != e) {
                Entry<K,V> next = e.next;
　　　　　　　　　// 当前元素总是直接放在数组下标的slot上，而不是放在链表的最后，所以
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
　　　　　　　　　// 把原来slot上的元素作为当前元素的下一个
                e.next = newTable[i];
　　　　　　　　 // 新迁移过来的节点直接放置在slot位置上
                newTable[i] = e;
                e = next;
            }
        }
    }

get方法：

    public V get(Object key) {
　　　　// 如果key为null，直接去table[0]处去检索即可
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key); // 根据key去获取Entry数组

        return null == entry ? null : entry.getValue();
    }
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }
　　　　　// 根据key的hashCode重新计算hash值
        int hash = (key == null) ? 0 : hash(key);
　　　　 // 获取查找的key所在数组中的索引，然后遍历链表，通过equals方法对比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;
    }

get方法相对比较简单，key(hashCode)-->hash-->indexFor-->index，找到对应位置table[index]，再查看是否有链表，通过key的equals方法对比找到对应的记录。

重写equal方法的同时必须重写hashCode()方法？如果不重写会有什么问题呢？

如：User类重写了equals方法却没有重写hashCode方法

public class User {
    private int age;
    private String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

}

将其作为key存入HashMap中，然后获取

        User user = new User(20, "yangyongjie");
        Map<User, String> map = new HashMap<>(1);
        map.put(user, "菜鸟");
        String value = map.get(new User(20, "yangyongjie"));
        System.out.println(value); //null

结果却为null，为什么呢？因为在默认情况下，hashCode方法是将对象的存储地址进行映射的，Object.hashCode()的实现是默认为每一个对象生成不同的int数值，它本身是native方法，一般与对象内存地址相关。而上面put和get的User虽然通过重写了equals方法使其逻辑上年龄和姓名相等的两个对象被判定为同一个对象，但是其两个对象的地址值并不相同，因此hashCode一定不同，那自然在put时的下标和get时的下标也不同。所以，如果重写了equals方法一定要同时重写hashCode方法。

此外，因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的自定义对象也必须重写这两个方法。

补充一下：未重写前的equals方法和hashCode方法都可以用来比较两个对象的地址值是否相同，不同的是，两个地址值不同的对象的hashCode可能相同，但是equals一定不同。

HashMap存在的一些问题

死链：

　　两个线程A，B同时对HashMap进行resize()操作，在执行transfer方法的while循环时，若此时当前槽上的元素为a-->b-->null

　　1、线程A执行到 Entry<K,V> next = e.next;时发生阻塞，此时e=a，next=b

　　2、线程B完整的执行了整段代码，此时新表newTable元素为b-->a-->null

　　3、线程A继续执行后面的代码，执行完一个循环之后，newTable变为了a<-->b，造成while(e!=null) 一直死循环，CPU飙升

扩容数据丢失：

　　同样在resize的transfer方法上

　　1、当前线程迁移过程中，其他线程新增的元素有可能落在已经遍历过的哈希槽上；在遍历完成之后，table数组引用指向了newTable，

　　　　这时新增的元素就会丢失，被无情的垃圾回收。

　　2、如果多个线程同时执行resize，每个线程又都会new Entry[newCapacity]，此时这是线程内的局部变量，线程之前是不可见的。迁移完成

　　　　后，resize的线程会给table线程共享变量，从而覆盖其他线程的操作，因此在被覆盖的new table上插入的数据会被丢弃掉。