Hashcode和HashMap的深入学习

Hashcode方法

1. Java中的hashcode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。

2. Hashcode是用来查找的。
   我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。

3. 但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。

也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 equals 来在这个桶里找到我们要的类。

4. 那么。重写了equals()，为什么还要重写hashCode()呢？
   想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什么用啊。

Hashcode与equals方法

1. hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
2. 如果两个对象相同，就是适用于equals(Java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；
3. 如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
4. 两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。
5. 也就是说对于两个对象，如果调用equals方法得到的结果为true，则两个对象的hashcode值必定相等；
6. 如果equals方法得到的结果为false，则两个对象的hashcode值不一定不同；
7. 如果两个对象的hashcode值不等，则equals方法得到的结果必定为false；
8. 如果两个对象的hashcode值相等，则equals方法得到的结果未知。

JDK1.7中的HashMap

HashMap里面存储的是静态内部类Entry对象，这个对象也是key-value结构。

HashMap的存取过程：

// 存储时:
int hash = key.hashCode(); // 1个key对应一个固定的hash值
int index = hash % Entry[].length;
Entry[index] = value;

// 取值时:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];
如果两个key通过int index = hash % Entry[].length得到了相同的index，就会跟在之间那个entry连接在后面，也就是按照顺序存储在后面的链表中，也就是解决hash冲突的拉链法。

HashMap的get()方法

源码：

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

当你传递一个key从hashmap总获取value的时候：
对key进行null检查。如果key是null，table[0]这个位置的元素将被返回。
key的hashcode()方法被调用，然后计算hash值。
indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置，使用刚才计算的hash值。
在获取了table数组的索引之后，会迭代链表，调用equals()方法检查key的相等性，如果equals()方法返回true，get方法返回Entry对象的value，否则，返回null。
由于可能会出现的Hash冲突，所以java采用了链地址法来处理冲突，首先会通过hashcode来查到对应的Entry对象，如果找到了之后发现这个链表上链接了多个Entry对象，则再调用equals方法对value进行逐一比较。但是如果当链表过长后，HashMap就会自动将链表转化为红黑树，以提高查找效率。

HashMap的put()方法

public V put(K key, V value) {
//判断当前数值是否需要初始化
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
//如果key为空，则put一个空值进去
        if (key == null)
            return putForNullKey(value);
//根据key计算出hashcode
        int hash = hash(key);
//根据计算出的hashcode定位所在的桶
        int i = indexFor(hash, table.length);
//如果桶是一个链表则需要遍历判断里面的 hashcode、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))) {
                V oldValue = e.value;
                e.value = value;
               e.recordAccess(this);
                return oldValue;
            }
        }
//如果桶是空的，说明当前位置没有数据存入；新增一个 Entry 对象写入当前位置。
       modCount++;
        addEntry(hash, key, value, i);
        return null;
   }

addEntry()方法

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

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

当调用 addEntry 写入 Entry 时需要判断是否需要扩容。
如果需要就进行两倍扩充，并将当前的 key 重新 hash 并定位。
而在 createEntry 中会将当前位置的桶传入到新建的桶中，如果当前桶有值就会在位置形成链表。

JDK1.8对HashMap的优化

在JDK1.7中，当发生Hash冲突时，在桶上形成的链表会变的越来越长，这样在查询时的效率就会越来越低；时间复杂度就由O(1)变成了O(N)。
所以到了1.8中，重点优化了这个问题。

1. TREEIFY_THRESHOLD 用于判断是否需要将链表转换为红黑树的阈值。
2. HashEntry 修改为 Node。
   Node中和1.7的Entry核心成员没有什么变化，主要变化的时get和put俩个方法、

put()方法

1. 判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
2. 根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
3. 如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等，相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。
4. 如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
5. 如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
6. 接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
7. 如果在遍历过程中找到 key 相同时直接退出遍历。
8. 如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。
9. 最后判断是否需要进行扩容。

get()方法

1. 首先将 key hash 之后取得所定位的桶。
2. 如果桶为空则直接返回 null 。
3. 否则判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
4. 如果第一个不匹配，则判断它的下一个是红黑树还是链表。
5. 红黑树就按照树的查找方式返回值。
6. 不然就按照链表的方式遍历匹配返回值。

引用文档
https://mp.weixin.qq.com/s/fZRPogkkUfBnhbZQB5r-uw
作者：纯洁的微笑