JDK1.8 HashMap有何不一样？

1. HashMap到底是什么

    基于哈希表的 Map 接口的实现。此实现提供全部可选的映射操做，并容许使用 null 值和 null 键。（除了非同步和容许使用 null 以外，HashMap 类与 Hashtable 大体相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操做（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。因此，若是迭代性能很重要，则不要将初始容量设置得过高（或将加载因子设置得过低）。

1. JDK1.7与JDK1.8中HashMap区别

   1. 最重要的一点是底层结构不同，1.7是数组+链表，1.8则是数组+链表+红黑树结构
   2. 插入键值对的put方法的区别，1.8中会将节点插入到链表尾部，而1.7中是采用头插
   3. jdk1.7中当哈希表为空时，会先调用inflateTable()初始化一个数组；而1.8则是直接调用resize()扩容
   4. jdk1.7中的hash函数对哈希值的计算直接使用key的hashCode值，而1.8中则是采用key的hashCode异或上key的hashCode进行无符号右移16位的结果，避免了只靠低位数据来计算哈希时致使的冲突，计算结果由高低位结合决定，使元素分布更均匀
   5. 插入键值对的put方法的区别，1.8中会将节点插入到链表尾部，而1.7中是采用头插
   6. 扩容时1.8会保持原链表的顺序，而1.7会颠倒链表的顺序
   7. 1.7中是只要不小于阈值就直接扩容2倍；而1.8的扩容策略会更优化，当数组容量未达到64时，以2倍进行扩容，超过64以后若桶中元素个数不小于7就将链表转换为红黑树，但若是红黑树中的元素个数小于6就会还原为链表，当红黑树中元素不小于32的时候才会再次扩容。

2. JDK1.8实现原理

   • 数据结构存储

HashMap是经过数组存储全部的数据，每一个元素所存放数组的下标，是根据该存储元素的key的Hash值与该数组的长度减去1作与运算，以下所示：
index = (length_of_array - 1) & hash_of_the_key
 数组中存放元素的数据结构使用了Node和TreeNode两种数据结构，在单个Hash值对应的存储元素小于8个时，默认值为Node的单向链表形式存储，当单个Hash值存储的元素大于8个时，其会使用TreeNode的数据结构存储。
 由于在单个Hash值对应的元素小于等于8个时，其查询时间最差为O(8)，可是当单个Hash值对应的元素大于8个时，再经过Node的单向链表的方式进行查询，速度上就会变得更慢了；这个时候HashMap就会将Node的普通节点转为TreeNode（红黑树）进行存储，这是因为TreeNode占用的空间大小约为常规节点的两倍，可是其查询速度能够获得保证，这个是经过空间换时间了。当TreeNode中包括的元素变得比较少时，为了存储空间的占用，也会转换为Node节点单向链表的方式实现，它们之间能够互相转换的。

• Node

  static class Node<K,V> implements Map.Entry<K,V> {
         final int hash;//当前Node的Hash值
         final K key;//当前Node的key
         V value;//当前Node的value
         Node<K,V> next;//表示指向下一个Node的指针，相同hash值的Node，经过next进行遍历查找
  
         Node(int hash, K key, V value, Node<K,V> next) {
             this.hash = hash;
             this.key = key;
             this.value = value;
             this.next = next;
         }
         ......
  }

• TreeNode

  static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
         TreeNode<K,V> parent;  // red-black tree links
         TreeNode<K,V> left;
         TreeNode<K,V> right;
         TreeNode<K,V> prev;    // needed to unlink next upon deletion
         boolean red;
         TreeNode(int hash, K key, V val, Node<K,V> next) {
             super(hash, key, val, next);
         }
         ......
  }

能够看到TreeNode使用的是红黑树（Red Black Tree）的数据结构，红黑树是一种自平衡二叉查找树，在进行插入和删除操做时经过特定操做保持二叉查找树的平衡，从而得到较高的查找性能，即便在最坏状况运行时间也是很是良好的，而且在实践中是很是高效的，它能够在O(log n)时间内作查找、插入和删除等操做，这里的n 是树中元素的数目。

• Hash值的计算方法

  // 计算指定key的hash值，原理是将key的hash code与hash code无符号向右移16位的值，执行异或运算。
  // 在Java中整型为4个字节32位，无符号向右移16位，表示将高16位移到低16位上，而后再执行异或运行，也
  // 就是将hash code的高16位与低16位进行异或运行。
  // 小于等于65535的数，其高16位所有都为0，于是将小于等于65535的值向右无符号移16位，则该数就变成了
  // 32位都是0，因为任何数与0进行异或都等于自己，于是hash code小于等于65535的key，其获得的hash值
  // 就等于其自己的hash code。
  static final int hash(Object key) {
     int h;
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

• 写入数据(put)

  public V put(K key, V value) {
   //首先根据hash方法，获取对应key的hash值，计算方法见后面
     return putVal(hash(key), key, value, false, true);
  }
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
     Node<K,V>[] tab; Node<K,V> p; int n, i;
   //判断用户存放元素的数组是否为空
     if ((tab = table) == null || (n = tab.length) == 0)
         //为空则进行初使化，并将初使化后的数组赋值给变量tab，数组的长值赋值给变量n
         n = (tab = resize()).length;
   //判断根据hash值与数组长度减1求与获得的下标，
   //从数组中获取元素并将其赋值给变量p(后续该变量p能够继续使用)，并判断该元素是否存在
     if ((p = tab[i = (n - 1) & hash]) == null)
         //若是不存在则建立一个新的节点，并将其放到数组对应的下标中
         tab[i] = newNode(hash, key, value, null);
     else {//根据数组的下标取到了元素，而且该元素p且不为空，下面要判断p元素的类型是Node仍是TreeNode
         Node<K,V> e; K k;
         //判断该数组对应下标取到的第一值是否是与正在存入值的hash值相同、
         //key相等（多是对象，也多是字符串），若是相等，则将取第一个值赋值给变量e
         if (p.hash == hash &&
             ((k = p.key) == key || (key != null && key.equals(k))))
             e = p;
         //判断取的对象是否是TreeNode，若是是则执行TreeNode的put方法
         else if (p instanceof TreeNode)
             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         else {//是普通的Node节点，
           //根据next属性对元素p执行单向链表的遍历
             for (int binCount = 0; ; ++binCount) {
                 //若是被遍历的元素最后的next为空，表示后面没有节点了，则将新节点与当前节点的next属性创建关系
                 if ((e = p.next) == null) {
                   //作为当前节点的后面的一个节点
                     p.next = newNode(hash, key, value, null);
                   //判断当前节点的单向连接的数量（8个）是否是已经达到了须要将其转换为TreeNode了
                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                         //若是是则将当前数组下标对应的元素转换为TreeNode
                         treeifyBin(tab, hash);
                     break;
                 }
                 //判断待插入的元素的hash值与key是否与单向链表中的某个元素的hash值与key是相同的，若是是则退出
                 if (e.hash == hash &&
                     ((k = e.key) == key || (key != null && key.equals(k))))
                     break;
                 p = e;
             }
         }
         //判断是否找到了与待插入元素的hash值与key值都相同的元素
         if (e != null) { // existing mapping for key
             V oldValue = e.value;
           //判断是否要将旧值替换为新值
             if (!onlyIfAbsent || oldValue == null)
                 //知足于未指定不替换或旧值为空的状况，执行将旧值替换为新值
                 e.value = value;
             afterNodeAccess(e);
             return oldValue;
         }
     }
     ++modCount;
     if (++size > threshold)
         resize();
     afterNodeInsertion(evict);
     return null;
  }

• 读取数据(get)

  public V get(Object key) {
         Node<K,V> e;
         //根据Key获取元素
         if ((e = getNode(hash(key), key)) == null)
             return null;
         if (accessOrder)
             afterNodeAccess(e);
         return e.value;
     }
  
     final Node<K,V> getNode(int hash, Object key) {
         Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
         //if语句的第一个判断条件
         if ((tab = table) != null //将数组赋值给变量tab，将判断是否为null
             && (n = tab.length) > 0 //将数组的长值赋值给变量n
             && (first = tab[(n - 1) & hash]) != null) {//判断根据hash和数组长度减1的与运算，计算出来的的数组下标的第一个元素是否是为空
           //判断第一个元素是否要找的元素，大部份状况下只要hash值太集中，或者元素不是不少，第一个元素每每都是须要的最终元素
             if (first.hash == hash && // always check first node
                 ((k = first.key) == key || (key != null && key.equals(k))))
                 //第一个元素就是要找的元素，由于hash值和key都相等，直接返回
                 return first;
             if ((e = first.next) != null) {//若是第一元素不是要找到的元，则判断其next指向是否还有元素
                 //有元素，判断其是不是TreeNode
                 if (first instanceof TreeNode)
                   //是TreeNode则根据TreeNode的方式获取数据
                     return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                 do {//是Node单向链表，则经过next循环匹配，找到就退出，不然直到匹配完最后一个元素才退出
                     if (e.hash == hash &&
                         ((k = e.key) == key || (key != null && key.equals(k))))
                         return e;
                 } while ((e = e.next) != null);
             }
         }
         //没有找到则返回null
         return null;
     }