HashMap原理分析（JDK1.8）

一、HashMap概述

1. 哈希（hash）/ 散列技术

1）散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f (key)

2）查找时，根据这个确定的对应关系找到给定值key的映射f (key) ，若查找集合中存在这个记录，则必定在f (key) 的位置上。这里我们把这种对应关系f称为散列函数，又称为哈希(Hash) 函数

3）按这个思想，采用散列技术将记录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表(Hash table)。 那么关键字对应的记录存储位置我们称为散列地址

4）通过某个函数f（f(x)的规则可以自己定义），使得：存储位置=f (关键字)，那样我们可以通过查找关键字不需要比较就可获得需要的记录的存储位置

5）整个散列过程其实就是两步

	(1) 在存储时，通过散列函数计算记录的散列地址，并按此散列地址存储该记录

	(2) 当查找记录时，我们通过同样的散列函数计算记录的散列地址，按此散列地址访问该记录。由于存取用的是同一个散列函数， 因此结果当然也是相同的

6）如果没有哈希冲突,散列表是一种非常高效的查找数据结构,其时间复杂度为O(1)

2. hash冲突

1）两个元素通过hash函数计算出的值是一样的，是同一个存储地址。当后面的元素要插入到这个地址时，发现已经被占用了，这时候就产生了hash冲突

3. HashMap概念

1）HashMap存储的是key-value的键值对，允许key为null，也允许value为null，线程不安全

	2）HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码（哈希表，x->f(x)）来决定存储的位置

	3）HashMap内部为数组+链表的结构，会根据key的hashCode值来确定数组的索引(确认放在哪个桶里)，如果发生hash冲突，HashMap会将同一个桶中的数据以链表的形式存储，但是如果发生hash冲突的概率比较高，就会导致同一个桶中的链表长度过长，遍历效率降低，所以在JDK1.8中如果链表长度到达阀值(默认是8)，就会将链表转换成红黑二叉树

	4）HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。学过数据结构的同学都知道，解决hash冲突的方法有很多，HashMap底层是通过链表来解决hash冲突的

	5）有时候两个key的hashCode可能会定位到一个桶中，这时就发生了hash冲突，如果HashMap的hash算法越散列，那么发生hash冲突的概率越低，如果数组越大，那么发生hash冲突的概率也会越低，但是数组越大带来的空间开销越多，但是遍历速度越快，这就要在空间和时间上进行权衡

	6）如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)

	7）threshold=负载因子 * length，也就是说数组长度固定以后， 如果负载因子越大，所能容纳的元素个数越多，如果超过这个值就会进行扩容(默认是扩容为原来的2倍)，0.75这个值是权衡过空间和时间得出的，建议大家不要随意修改，如果在一些特殊情况下，比如空间比较多，但要求速度比较快，这时候就可以把扩容因子调小以较少hash冲突的概率。相反就增大扩容因子(这个值可以大于1)

	8）size就是HashMap中键值对的总个数。还有一个字段是modCount，记录是发生内部结构变化的次数，如果put值，但是put的值是覆盖原有的值，这样是不算内部结构变化的

---

二、HashMap数据结构

1. Node (桶是一个数组，单个table[i] = 1个或者多个Node)

// Node本质上是一个Map.存储着key-value
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;             //保存该桶的hash值
final K key;                //不可变的key
V value;                    
Node<K,V> next;      //指向一个数据的指针

Node(int hash, K key, V value, Node<K,V> next) {
    this.hash = hash;
    this.key = key;
    this.value = value;
    this.next = next;
}

2. 类的属性

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列号
    private static final long serialVersionUID = 362498820763181265L;    
    // 默认的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30; 
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8; 
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组，总是2的幂次倍
    transient Node<k,v>[] table; 
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数，注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;   
    // 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
    int threshold;
    // 填充因子
    final float loadFactor;
}  

3. hashMap是通过key的hashCode的高16位和低16位异或后和桶的数量取模得到索引位置（有时间深入研究）

static final int hash(Object key) {   //jdk1.8 & jdk1.7
     int h;
     // h = key.hashCode() 为第一步 取hashCode值
     // h ^ (h >>> 16)  为第二步 高位参与运算
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

1）右位移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，以此来加大低位的随机性

2）而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来

3）假如没有进行高位运算，那最后参与运算的永远只是取模运算的最后几位，相似性会比较大

---

三、HashMap的put方法实现

1. 实现思路

1）table[]是否为空

2）判断table[i]处是否插入过值

3）判断链表长度是否大于8，如果大于就转换为红黑二叉树，并插入树中

4）判断key是否和原有key相同，如果相同就覆盖原有key的value，并返回原有value

5）如果key不相同，就插入一个key，记录结构变化一次

2. 源码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
           boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 判断table是否为空，如果是空的就创建一个table，并获取他的长度
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 如果计算出来的索引位置之前没有放过数据，就直接放入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        // 进入这里说明索引位置已经放入过数据了
        Node<K,V> e; K k;
        // 判断put的数据和之前的数据是否重复(即是否是同一个key)
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k)))) //  //key的地址或key的equals()只要有一个相等就认为key重复了，就直接覆盖原来key的value
            e = p;
        // 判断是否是红黑树，如果是红黑树就直接插入树中    
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
        	// 如果不是红黑树，就遍历每个节点，判断链表长度是否大于8，如果大于就转换为红黑树
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 判断索引每个元素的key是否可要插入的key相同，如果相同就直接覆盖
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 如果e不是null，说明没有迭代到最后就跳出了循环，说明链表中有相同的key，因此只需要将value覆盖，并将oldValue返回即可
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 说明没有key相同，因此要插入一个key-value，并记录内部结构变化次数
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}	

---

四、HashMap的get方法实现

1. 实现思路

1）判断表或key是否是null，如果是直接返回null

2）判断索引处第一个key与传入key是否相等，如果相等直接返回

3）如果不相等，判断链表是否是红黑二叉树，如果是，直接从树中取值

4）如果不是树，就遍历链表查找

2. 源码

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 如果表不是空的，并且要查找索引处有值，就判断位于第一个的key是否是要查找的key
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            // 如果是，就直接返回
            return first;
        // 如果不是就判断链表是否是红黑二叉树，如果是，就从树中取值    
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 如果不是树，就遍历链表    
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}	

---

五、HashMap的扩容机制

1. 我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置

2. 元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化

3. 我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap” ，可以看看下图为16扩充为32的resize示意图

4. 这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置

5. 扩容是一个特别耗性能的操作，所以当程序员在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容

---

参考网址

哈希算法为什么存取速度快？

HashMap JDK1.8实现原理

HashMap JDK1.8原理分析

【集合框架】JDK1.8源码分析之HashMap（一）(有一系列)

注：文章是经过参考其他的文章然后自己整理出来的，有可能是小部分参考，也有可能是大部分参考，但绝对不是直接转载，觉得侵权了我会删，我只是把这个用于自己的笔记，顺便整理下知识的同时，能帮到一部分人。
ps : 有错误的还望各位大佬指正,小弟不胜感激