从数据结构、位运算和源码浅析HashMap

HashMap的数据结构

数据结构

• String[]数组

首先想到的就是String[]数组，声明指定的长度后，然后根据索引向里面插入数据。但它的缺点是，长度不够时扩容麻烦。

• ArrayList数组
  面对这个缺点可以选择ArrayList数组，支持动态扩容，查询速度很快（可以根据索引快速查找），顺序插入也快。但它的缺点是，在数组的中间元素插入删除元素时，要移动索引，数据量大时，频繁插入删除速度就会慢。

• LinkedList链表
  -面对这个缺点可以选择LinkedList链表，插入删除元素快。但查询速度较慢。

ArrayList、LinkedList可以根据场景选择。

如果不知道场景是读多写少，还写多读少，能不能把二者优势结合？

• HashMap
  JDK1.7：数组+链表
  JDK1.8：数组+链表+红黑树
  HashMap，集中数据、链表的优点。通过hash算法为key生成一个对应的int类型值作为数组下标，方便查询时快读定位元素，但有可能出现不同的key生成的int值一样，即hash冲突，这种情况就需要链表。把冲突的value值通过链表next关联起来。但如果数据量较大hash冲突较多，链表会很长，查找的时间复杂度为O(n)。

O(n)，就代表数据量增大几倍，耗时也增大几倍。比如常见的遍历算法。再比如时间复杂度O(n^2 )，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的O(n^2)的算法，对n个数排序，需要扫描n×n次。

为什么在JDK1.8加入了红黑树

于是在JDK1.8加入了红黑树，来加快读取速度，提高查询性能。
比二叉树、b+Tree平衡二叉树性能好，变形开销小和读取路径短。查找时间复杂度为O(logn)。

O(logn)，当数据增大n倍时，耗时增大logn倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度）。二分查找就是O(logn)的算法，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。

HashMap的数组容量为什么是2的整数次幂

/**
 * 10000、16
 * 必须是2的N次方，或者叫2的整数次幂
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

1、方便hash计算和数组的下标计算；
2、扩容有关：扩容后元素的位置可能是原来的位置，或者原来的位置+扩容大小，每次扩容后只会分散最多两个位置；

HashMap里的桶是什么

每个元素存的位置就叫桶，发生hash冲突后，链表或红黑树也是桶。

HashMap源码解析

关键的结构

/**
 * 数组初始长度
 * 10000、16
 * 必须是2的N次方，或者叫2的整数次幂
 */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

/**
 * 数组的最大容量
 */
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
 * 加载因子，扩容时使用，比如16*0.75f=12时就扩容
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * 树化的阈值，链表树化的一个条件
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 反树化的阈值，树到链表
 */
static final int UNTREEIFY_THRESHOLD = 6;
/**
 * 最小树化的数组容量，链表树化的另一个条件
 * 16、32、64
 */
static final int MIN_TREEIFY_CAPACITY = 64;

/**
 * 数组
 */
transient Node<K,V>[] table;

/**
 * 链表
 */
static class Node<K,V> implements Map.Entry<K,V> {
   final int hash;
   final K key;
   V value;
   Node<K,V> next;  // 下个元素
   
   // ...
}

/**
 * JDK1.8加入的红黑树
 */
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;
   
   // ...   
}

数组下标定位 (n-1)&hash

(n-1)&hash 等价于 hash%16，前者二进制运算性能更好。
16-1=15，二进制是1111，而&的特点是只有1:1时才为1，所以&运算后最大值为1111，最小值为0000，即0~15。与hash%16结果一样。

&运算规则可以参考：
Java中与&、或|、异或^运算符的使用规则与区别

put()流程

public V put(K key, V value) {
   return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

hash(Object key)等价于

static final int hash(Object key) {
  if(key == null) return 0;
  int h = key.hashCode(); //32位
  int temp = h >>> 16; //向右位移16位，高位变低位，高位填充0
  int hashValue = h ^ temp; //异或运算，结果更公平，使元素更加分散
  return hashValue;
}

^运算的特点是0:0、1:1为0，1:0、0:1为1，结果为0或1的概率都为50，更加公平；向右位移16位，高位变低位，高位填充0，也即h低位和高位异或，使元素更加分散。结合上面&，最后这有低位1111参与&运算。

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)
       n = (tab = resize()).length;
   // 桶为空，直接插入元素
   if ((p = tab[i = (n - 1) & hash]) == null)
       tab[i] = newNode(hash, key, value, null); //next为null
   // hash冲突时
   else {
       Node<K,V> e; K k;
       // 桶里面的hash和新hash相同
       // 1.key是同一个，p赋值给e，是否用value覆盖看下面
       if (p.hash == hash &&
           ((k = p.key) == key || (key != null && key.equals(k))))
           e = p;
       // 是否是树化
       else if (p instanceof TreeNode)
           e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
       // hash冲突，但key不相等
       else {
           for (int binCount = 0; ; ++binCount) {
           	   // 放在链表的最后
               if ((e = p.next) == null) {
                   p.next = newNode(hash, key, value, null);
                   // 树化，-1减掉自己
                   if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                       treeifyBin(tab, hash);
                   break;
               }
               // 如果是自己break
               if (e.hash == hash &&
                   ((k = e.key) == key || (key != null && key.equals(k))))
                   break;
               // 转换，向下循环
               p = e;
           }
       }
       // key-value已存在，操作重复的值
       if (e != null) {
           V oldValue = e.value;
           //onlyIfAbsent表示value只能赋值一次，默认为false，
           //所以!onlyIfAbsent为true，表示可以用新value值替换旧value值
           //或者onlyIfAbsent=true，但oldValue为null也可以替换
           if (!onlyIfAbsent || oldValue == null)
               e.value = value;
           afterNodeAccess(e);
           // 返回旧value值
           return oldValue;
       }
   }
   // 操作新值，记录修改次数，用于扩容
   ++modCount;
   if (++size > threshold)
       resize();
   afterNodeInsertion(evict);
   return null;
}

hash冲突

key=king和key=peter时，hash值不一样，但下标(n-1)&hash的值是一样的。

HashMap在JDK1.7中死循环的分析

JDK1.7中在多线程高并发情况下，使用HashMap的put()会引发死循环，造成CPU飙升接近100%，问题就出现在Entry链表形成环形结构，一旦形成环形结构，Entry的next的节点永远不会为空，就会产生死循环获取Entry。

原因就在于JDK1.7中作者为了提高链表查询效率，认为最后插入的可能会最近使用，就采取了头插法。在多线程高并发下就很容易形成环形链表。