吃透JDK1。8中HashMap的源码和底层数据结构

　　1 HashMap 简介
　　HashMap   主要用来存放键值对，它基于哈希表的 Map 接口实现，在Java中是常用 集合，它是非线程安全的。
　　HashMap  存储的是 key-vlaue   格式数据，需要注意的是其key和value的值都可以为空，但是key值为空的只能有一个，value咋可以有多个空值数据。
　　JDK1.8 之前 HashMap   由 【数组+链表  】   组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（＂拉链法＂解决冲突）。
　　JDK1.8 以后的 HashMap   由 【数组+链表+红黑树】   组成的，以此来加快查询速度。使用红黑树的两个条件：
　　1、当链表长度大于阈值（默认为 8）时，将链表转化为红黑树。
　　2、在转换之前会先判断当前数组的长度，如果当前数组长度小于 64，那么会先对数组扩容，也就是数组长度必须超过64。2 底层数据结构分析2.1 JDK8 之前
　　JDK8   之前  HashMap   底层是  【数组和链表】  结合在一起使用也就是 链表散列  。
　　HashMap   通过 key 的 hashCode 经过 扰动函数  处理过后得到 hash 值，然后通过  (n - 1) & hash   判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。
　　扰动函数  ：  HashMap   的  hash()  。使用 hash() 是为了防止实现较差的 hashCode() 方法【换种说法就是用hash()可以减少碰撞】。
　　JDK8    HashMap   的  hash()  源码:
　　JDK8   的  hash()   相比于  JDK7 hash()   更加简化，但是原理不变。源码：     static final int hash(Object key) {       int h;       // key.hashCode()：返回散列值也就是hashcode       // ^ ：按位异或       // >>>:无符号右移，忽略符号位，空位都以0补齐       return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);   }Copy to clipboardErrorCopied
　　JDK7   的  HashMap   的  hash()   源码： static int hash(int h) {     // 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); }Copy to clipboardErrorCopied
　　对比JDK8和JDK7的hash()源码，可以看出jdk7中的hash()扰动了4次，因此其性能相对于jdk8要差一点。
　　＂拉链法＂  ：将链表和数组相结合。也就是创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
　　2.2 JDK8 之后
　　JDK8   之后在解决哈希冲突时变化很大。
　　当链表长度大于阈值（默认为 8）时，会首先调用  treeifyBin()  。这个方法会根据 HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是执行 resize()   对数组扩容。相关源码这里就不贴了，重点关注 treeifyBin()   即可！
　　HashMap  类的属性： public class HashMap extends AbstractMap implements Map, 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[] table;     // 存放具体元素的集     transient Set> entrySet;     // 存放元素的个数，注意这个不等于数组的长度。     transient int size;     // 每次扩容和更改map结构的计数器     transient int modCount;     // 临界值(容量*填充因子) 当实际大小超过临界值时，会进行扩容     int threshold;     // 加载因子     final float loadFactor; }Copy to clipboardErrorCopiedloadFactor 加载因子 loadFactor 加载因子是控制数组存放数据的疏密程度，loadFactor 越趋近于 1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor 越小，也就是趋近于 0，数组中存放的数据(entry)也就越少，也就越稀疏。 loadFactor 太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor 的默认值为 0.75f 是官方给出的一个比较好的临界值 。给定的默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。 threshold threshold = capacity * loadFactor ，当 Size>=threshold 的时候，那么就要考虑对数组的扩增了，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准 。
　　Node   节点类源码: // 继承自 Map.Entry static class Node implements Map.Entry {        final int hash;// 哈希值，存放元素到hashmap中时用来与其他元素hash值比较        final K key;//键        V value;//值        // 指向下一个节点        Node next;        Node(int hash, K key, V value, Node next) {             this.hash = hash;             this.key = key;             this.value = value;             this.next = next;         }         public final K getKey()        { return key; }         public final V getValue()      { return value; }         public final String toString() { return key + ＂=＂ + value; }         // 重写hashCode()方法         public final int hashCode() {             return Objects.hashCode(key) ^ Objects.hashCode(value);         }          public final V setValue(V newValue) {             V oldValue = value;             value = newValue;             return oldValue;         }         // 重写 equals() 方法         public final boolean equals(Object o) {             if (o == this)                 return true;             if (o instanceof Map.Entry) {                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;                 if (Objects.equals(key, e.getKey()) &&                     Objects.equals(value, e.getValue()))                     return true;             }             return false;         } }Copy to clipboardErrorCopied
　　TreeNode  类源码: static final class TreeNode extends LinkedHashMap.Entry {         TreeNode parent;  // 父         TreeNode left;    // 左         TreeNode right;   // 右         TreeNode prev;    // needed to unlink next upon deletion         boolean red;           // 判断颜色         TreeNode(int hash, K key, V val, Node next) {             super(hash, key, val, next);         }         // 返回根节点         final TreeNode root() {             for (TreeNode r = this, p;;) {                 if ((p = r.parent) == null)                     return r;                 r = p;        }Copy to clipboardErrorCopied3 HashMap 源码分析3.1 构造方法源码分析
　　HashMap   中有四个构造方法源码分析：     // 默认构造函数。     public HashMap() {         this.loadFactor = DEFAULT_LOAD_FACTOR; // all   other fields defaulted      }       // 包含另一个＂Map＂的构造函数      public HashMap(Map<? extends K, ? extends V> m) {          this.loadFactor = DEFAULT_LOAD_FACTOR;          putMapEntries(m, false);//下面会分析到这个方法      }       // 指定＂容量大小＂的构造函数      public HashMap(int initialCapacity) {          this(initialCapacity, DEFAULT_LOAD_FACTOR);      }       // 指定＂容量大小＂和＂加载因子＂的构造函数      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;          this.threshold = tableSizeFor(initialCapacity);      }Copy to clipboardErrorCopied
　　putMapEntries()   方法源码分析： final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {     int s = m.size();     if (s > 0) {         // 判断table是否已经初始化         if (table == null) { // pre-size             // 未初始化，s为m的实际元素个数             float ft = ((float)s / loadFactor) + 1.0F;             int t = ((ft < (float)MAXIMUM_CAPACITY) ?                     (int)ft : MAXIMUM_CAPACITY);             // 计算得到的t大于阈值，则初始化阈值             if (t > threshold)                 threshold = tableSizeFor(t);         }         // 已初始化，并且m元素个数大于阈值，进行扩容处理         else if (s > threshold)             resize();         // 将m中的所有元素添加至HashMap中         for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {             K key = e.getKey();             V value = e.getValue();             putVal(hash(key), key, value, false, evict);         }     } }Copy to clipboardErrorCopied3.2 put() 方法源码分析
　　HashMap   仅提供了  put()   用于添加元素， putVal()   只是给  put()   内部调用的一个方法。
　　putVal()   添加元素的分析： 如果定位到的数组位置没有元素 就直接插入。 如果定位到的数组位置有元素，则比较要插入的 key ，如果 key 相同则直接覆盖，如果 key 不同，就判断当前位置是否是一个树节点，如果是就调用  e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value)   将元素添加进去。如果不是就遍历链表插入。
　　注意：直接覆盖之后不会有后续的操作了。 当链表长度大于阈值（默认为 8）并且  HashMap   数组长度超过 64 的时候才会执行链表转红黑树的操作，否则就只是对数组扩容 。public V put(K key, V value) {     return putVal(hash(key), key, value, false, true); }  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                    boolean evict) {     Node[] tab; Node p; int n, i;     // table未初始化或者长度为0，进行扩容     if ((tab = table) == null || (n = tab.length) == 0)         n = (tab = resize()).length;     // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)     if ((p = tab[i = (n - 1) & hash]) == null)         tab[i] = newNode(hash, key, value, null);     // 桶中已经存在元素（处理hash冲突）     else {         Node e; K k;         // 判断table[i]中的元素是否与插入的key一样，若相同那就直接使用插入的值p替换掉旧的值e。         if (p.hash == hash &&             ((k = p.key) == key || (key != null && key.equals(k))))                 e = p;         // 判断插入的是否是红黑树节点         else if (p instanceof TreeNode)             // 放入树中             e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);         // 不是红黑树节点则说明为链表结点         else {             // 在链表最末插入结点             for (int binCount = 0; ; ++binCount) {                 // 到达链表的尾部                 if ((e = p.next) == null) {                     // 在尾部插入新结点                     p.next = newNode(hash, key, value, null);                     // 结点数量达到阈值(默认为 8 )，执行 treeifyBin 方法                     // 这个方法会根据 HashMap 数组来决定是否转换为红黑树。                     // 只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是对数组扩容。                     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;                 // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表                 p = e;             }         }         // 表示在桶中找到key值、hash值与插入元素相等的结点         if (e != null) {             // 记录e的value             V oldValue = e.value;             // onlyIfAbsent为false或者旧值为null             if (!onlyIfAbsent || oldValue == null)                 //用新值替换旧值                 e.value = value;             // 访问后回调             afterNodeAccess(e);             // 返回旧值             return oldValue;         }     }     // 结构性修改     ++modCount;     // 实际大小大于阈值则扩容     if (++size > threshold)         resize();     // 插入后回调     afterNodeInsertion(evict);     return null; }Copy to clipboardErrorCopied3.3 get() 方法源码分析public V get(Object key) {     Node e;     return (e = getNode(hash(key), key)) == null ? null : e.value; }  final Node getNode(int hash, Object key) {     Node[] tab; Node first, e; int n; K k;     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) {             // 在树中get             if (first instanceof TreeNode)                 return ((TreeNode)first).getTreeNode(hash, key);             // 在链表中get             do {                 if (e.hash == hash &&                     ((k = e.key) == key || (key != null && key.equals(k))))                     return e;             } while ((e = e.next) != null);         }     }     return null; }Copy to clipboardErrorCopied3.4 resize() 方法源码分析
　　注意在程序编写中应尽可能的避免使用resize()，因为每次的扩容都会遍历hash表所有元素对hash重新分配，非常的耗时。 final Node[] resize() {     Node[] oldTab = table;     int oldCap = (oldTab == null) ? 0 : oldTab.length;     int oldThr = threshold;     int newCap, newThr = 0;     if (oldCap > 0) {         // 超过最大值就不再扩充了，就只好随你碰撞去吧         if (oldCap >= MAXIMUM_CAPACITY) {             threshold = Integer.MAX_VALUE;             return oldTab;         }         // 没超过最大值，就扩充为原来的2倍         else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)             newThr = oldThr << 1; // double threshold     }     else if (oldThr > 0) // initial capacity was placed in threshold         newCap = oldThr;     else {         // signifies using defaults         newCap = DEFAULT_INITIAL_CAPACITY;         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);     }     // 计算新的resize上限     if (newThr == 0) {         float ft = (float)newCap * loadFactor;         newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);     }     threshold = newThr;     @SuppressWarnings({＂rawtypes＂,＂unchecked＂})         Node[] newTab = (Node[])new Node[newCap];     table = newTab;     if (oldTab != null) {         // 把每个bucket都移动到新的buckets中         for (int j = 0; j < oldCap; ++j) {             Node e;             if ((e = oldTab[j]) != null) {                 oldTab[j] = null;                 if (e.next == null)                     newTab[e.hash & (newCap - 1)] = e;                 else if (e instanceof TreeNode)                     ((TreeNode)e).split(this, newTab, j, oldCap);                 else {                     Node loHead = null, loTail = null;                     Node hiHead = null, hiTail = null;                     Node next;                     do {                         next = e.next;                         // 原索引                         if ((e.hash & oldCap) == 0) {                             if (loTail == null)                                 loHead = e;                             else                                 loTail.next = e;                             loTail = e;                         }                         // 原索引+oldCap                         else {                             if (hiTail == null)                                 hiHead = e;                             else                                 hiTail.next = e;                             hiTail = e;                         }                     } while ((e = next) != null);                     // 原索引放到bucket里                     if (loTail != null) {                         loTail.next = null;                         newTab[j] = loHead;                     }                     // 原索引+oldCap放到bucket里                     if (hiTail != null) {                         hiTail.next = null;                         newTab[j + oldCap] = hiHead;                     }                 }             }         }     }     return newTab; }Copy to clipboardErrorCopied
　　至此HashMap源码分析到此为止了，在这里提出一个疑问，既然HashMap是线程不安全的，那么实际项目中我们又怎么解决这个问题呢？关注+收藏，下期我们来解决一下这个问题。