HashMap

一、定义

        HashMap是基于哈希表的Map接口实现，以Key-Value形式存在，主要用来存放键值对，其中键不可重复，而值可以重复，两者都可以为null。HashMap的实现不是同步的，这意味着线程不安全，HashTable是基于同步锁synchronized的线程安全的HashMap，但性能并不乐观。另外，HashMap的映射不是有序的。HashSet是只存放Key的HashMap。

• JDK1.7 HashMap数据结构：数组 + 链表
• JDK1.8 HashMap数据结构：数组 + 链表 + 红黑树 

 

 为什么在JDK1.8以后，HashMap要增加红黑树？

二、哈希表

        哈希表也称为散列表，是一种根据关键值而直接进行访问的数据结构。通过关键值映射到表中的一个位置来访问记录，加快查找速度。在链表和数组中查找某个关键值，算法复杂度为O(n),但对于哈希表来说就是O(1)。

        将关键值映射到表中的位置的函数叫散列函数，存放记录的数组叫散列表，只要O(1)的复杂度就能完成。

         多个key通过散列函数会得到相同的值，这时候怎么处理呢？

        （1）开放地址法

         开放地址法就是每当出现地址冲突就采用探测算法查找下一个空位置。可能会出现多次冲突，需要良好的散列算法和探测算法。

        （2）链地址法

         链地址法也称为拉链法，就是被所有的冲突数据都以链表或者数组的形式存放到一起，当冲突数据过多的时候，链表和数组就会很长，查找时间也会很长。

 三、JDK1.7 HashMap的数据结构

        JDK1.7以前HashMap的实现是基于数组+链表，链表使用头插法，即使哈希函数取得再好，也很难达到元素百分百均匀分布。

        当HashMap中有大量元素都存放到同一个桶中的时候，桶下会有一条很长的链表，极端情况下HashMap相当于一个单向链表，此时时间复杂度为O(n)。

 四、JDK1.8 HashMap的数据结构

        JDK1.8中HashMap采用数组+链表+红黑树，链表使用尾插法。

        桶的结构可能是链表也可能是红黑树，当链表长度大于阈值（或者红黑树的边界值，默认为8）并且数组长度大于64时，链表转红黑树。

五、类构造器

// HashMap类构造器
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable{}

 

        JDK提供了一个抽象类AbstractMap类，该类实现了Map接口，如果不想实现所有的Map接口方法，可以选择继承AbstractMap。

        HashMap同时实现了Cloneable,Serializable接口，分别用来支持对象克隆以及对象序列化。

        HashMap既然继承了AbstractMap类，又实现Map接口，用意为何呢?

六、字段属性

  //序列化和反序列化时，通过该字段进行版本一致性验证
  private static final long serialVersionUID = 362498820763181265L;
  //默认 HashMap 集合初始容量为16（必须是 2 的倍数）
  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
  //集合的最大容量，如果通过带参构造指定的最大容量超过此数，默认还是使用此数
  static final int MAXIMUM_CAPACITY = 1 << 30;
  //默认的填充因子
  static final float DEFAULT_LOAD_FACTOR = 0.75f;
  //当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
  static final int TREEIFY_THRESHOLD = 8;
  //当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
  static final int UNTREEIFY_THRESHOLD = 6;
  /**(JDK1.8新增)
  * 当集合中的容量大于这个值时，表中的桶才能进行树形化 ，否则桶内元素太多时会扩容，
  * 而不是树形化 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
  */
  static final int MIN_TREEIFY_CAPACITY = 64;
  /**
  * 初始化使用，长度总是 2的幂
  */
  transient Node<K,V>[] table;
  /**
  * 保存缓存的entrySet（）
  */
  transient Set<Map.Entry<K,V>> entrySet;
  /**
  * 此映射中包含的键值映射的数量。（集合存储键值对的数量）
  */
  transient int size;
  /**
  * 跟前面ArrayList和LinkedList集合中的字段modCount一样，记录集合被修改的次数
  * 主要用于迭代器中的快速失败
  */
  transient int modCount;
  /**
  * 调整大小的下一个大小值（容量*加载因子）。capacity * load factor
  */
  int threshold;
  /**
  * 散列表的加载因子。
  */
  final float loadFactor;

        1. Node<K,V>[] table

            这个table字段就是HashMap中的数组，他的默认初始化长度是 DEFAULT_INITIAL_CAPACITY=16,，是JDK声明数组的长度，总是2的n次方，是由于HashMap中的hashCode()方法，为了减少冲突而决定的。

        2.size

        存放key-value的实时对数。

        3.loadFactor

        装载因子，用来衡量HashMap是否需要进行扩容的判断依据，loadFactor=size/capacity，使用存储的个数除以桶的数量，也就是capacity，也就是table.length.

        loadFactor默认0.75，是时间和空间上的衡量，在实际应用中，如果有特殊需求可以进行调整，如果内存充足，追求高效查找，可以将因子减小；如果内存紧张，不看重效率，可是将因子增大,loadFactor可以大于1。但是并不建议修改这个值。

        4.threshold

        threshold=capacity*loadFactor，这个值表示当前HashMap的界限值，当size>threshold，执行resize(),扩容后的HashMap容量是之前的两倍。

七、构造函数

         1.默认的无参构造函数

/**
 * 默认构造函数，初始化加载因子loadFactor = 0.75
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
 }

        2.指定初始容量的构造函数

/**
  *
  * @param initialCapacity 指定初始化容量
  * @param loadFactor 加载因子 0.75
 */
public HashMap(int initialCapacity, float loadFactor) {
    //初始化容量不能小于 0 ，否则抛出异常
    if (initialCapacity < 0)
      throw new IllegalArgumentException("Illegal initial capacity: " +
                       initialCapacity);
    //如果初始化容量大于2的30次方，则初始化容量都为2的30次方
    if (initialCapacity > MAXIMUM_CAPACITY)
      initialCapacity = MAXIMUM_CAPACITY;
    //如果加载因子小于0，或者加载因子是一个非数值，抛出异常
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
      throw new IllegalArgumentException("Illegal load factor: " +
                       loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
 }
  // 返回大于等于initialCapacity的最小的二次幂数值。
  // >>> 操作符表示无符号右移，高位取0。
  // | 按位或运算
  static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 }

八、哈希算法

        哈希表是通过散列函数确定索引位置的，散列函数设计 越好，冲突越少元素越均匀。

哈希函数：

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }
 
 i = (table.length - 1) & hash;//这一步是在后面添加元素putVal()方法中进行位置的确定

 从函数中可以分为三步：

1. 取hashCode值：key.hashCode()
2. 高位参与运算：h>>>16
3. 取模运算的出索引位置：（table.length-1）&hash

为了让元素分布更均匀，我们首先想到将hash%table.length来获取索引位置，但这样的运算开销大，所以使用hash&（table.length-1）来得到索引位，在运算效率上的得到优化，当table.length=2^n时，hash&(table.length-1)<=>hash%table.length,但是&比%具备更高的运算效率。

 所以在数组长度为2的n次方时既能够保证均匀，又能高效计算索引位置。

为什么要让高位参与运算呢？

hashCode() 计算得出一个32位的int型值，通过hashCode的高16位异或hashCode低16位：(h = key.hashCode()) ^(h>>>16),保证table.length在比较小的时候，保证整个hashCode都能参与到运算中去。

 九、添加元素

        

//hash(key)就是上面讲的hash方法，对其进行了第一步和第二步处理
  public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
 }
  /**
  *
  * @param hash 索引的位置
  * @param key 键
  * @param value 值
  * @param onlyIfAbsent true 表示不要更改现有值
  * @param evict false表示table处于创建模式
  * @return
  */
  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为null或者长度为0，则进行初始化
    //resize()方法本来是用于扩容，由于初始化没有实际分配空间，这里用该方法进行空间分配，后面会详细讲解该方法
    if ((tab = table) == null || (n = tab.length) == 0)
      n = (tab = resize()).length;
    //注意：这里用到了前面讲解获得key的hash码的第三步，取模运算，下面的if-else分别是tab[i] 为null和不为null
    if ((p = tab[i = (n - 1) & hash]) == null)
      tab[i] = newNode(hash, key, value, null);//tab[i] 为null，直接将新的
key-value插入到计算的索引i位置
    else {//tab[i] 不为null，表示该位置已经有值了
      Node<K,V> e; K k;
      if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))
        e = p;//节点key已经有值了，直接用新值覆盖
      //该链是红黑树
      else if (p instanceof TreeNode)
        e = ((TreeNode<K,V>)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，转换成红黑树
            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
              treeifyBin(tab, hash);
            break;
          }
          //key已经存在直接覆盖value
          if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            break;
          p = e;
        }
      }
      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;
 }

1.  判断键值对数组table是否为空或为null，否则执行resize()进行扩容。
2. 根据计算出的hash值插入数据到索引i,如果table[i]==null,直接新建节点添加，执行6，如果table[i] != null，执行3。
3. 判断table[i]的首个元素是否和key一样，如果一样直接覆盖value，否则执行4，是否一样指的是hashCode和equals()。
4. 判断table[i]是否是TreeNode,如果是，则在红黑树中插入键值，否则执行5。
5. 遍历table[i],判断链表长度是否大于8，大于8的话，链表转红黑树，在红黑树中插入键值，否则在链表尾部追加键值，遍历过程发现key相同，则进行覆盖。
6. 插入成功后，判断键值对数量size是否超过最大容量threshold，如果超过，进行扩容。
7. 如果新插入的key不存在，则返回null，如果存在，就将被覆盖的value返回。

十、扩容机制 

         当size>threshold(capacity*loadFactor)时，table需要进行扩容操作，也就是执行resize()

JDK1.7 扩容源码：

//参数 newCapacity 为新数组的大小
  void resize(int newCapacity) {
    Entry[] oldTable = table;//引用扩容前的 Entry 数组
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {//扩容前的数组大小如果已经达到最大(2^30)了
      threshold = Integer.MAX_VALUE;///修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
      return;
   }
    Entry[] newTable = new Entry[newCapacity];//初始化一个新的Entry数组
    transfer(newTable, initHashSeedAsNeeded(newCapacity));//将数组元素转移到新数组里面
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY +
1);//修改阈值
 }
  void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {//遍历数组
      while(null != e) {
        Entry<K,V> next = e.next;
        if (rehash) {
          e.hash = null == e.key ? 0 : hash(e.key);
       }
        int i = indexFor(e.hash, newCapacity);//重新计算每个元素在数组中的索引位置
        e.next = newTable[i];//标记下一个元素，添加是链表头添加
        newTable[i] = e;//将元素放在链上
        e = next;//访问下一个 Entry 链上的元素
     }
   }
 }

 在JDK1.7 的resize()中,先穿件一个newSize大小的Entry[]（在JDK1.8 后改为了Node），然后将原有的元素迁移到新的table中，并且对所有键值对进行hash重构，出现哈希冲突后，就将元素插入到链表的头结点。

 JDK1.8 扩容源码

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null，则长度赋值0
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {//如果原数组长度大于0
      if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30)
        threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
        return oldTab;
     }
      //原数组长度大于等于初始化长度16，并且原数组长度扩大1倍也小于2^30次方
      else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
          oldCap >= DEFAULT_INITIAL_CAPACITY)
        newThr = oldThr << 1; // 阀值扩大1倍
   }
    else if (oldThr > 0) //旧阀值大于0，则将新容量直接等于就阀值
      newCap = oldThr;
    else {//阀值等于0，oldCap也等于0（集合未进行初始化）
      newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
      newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
   }
    //计算新的阀值上限
    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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
      //把每个bucket都移动到新的buckets中
      for (int j = 0; j < oldCap; ++j) {
        Node<K,V> e;
        if ((e = oldTab[j]) != null) {
          oldTab[j] = null;//元数据j位置置为null，便于垃圾回收
          if (e.next == null)//数组没有下一个引用（不是链表）
            newTab[e.hash & (newCap - 1)] = e;
          else if (e instanceof TreeNode)//红黑树
           ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
          else { // preserve order
            Node<K,V> loHead = null, loTail = null;
            Node<K,V> hiHead = null, hiTail = null;
            Node<K,V> 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;
 }

JDK1.8 中的扩容详解：

 

在JDK1.8 中，首先计算桶数组的容量newCap和新阈值newThr,然后将院级喝的元素重新映射到新集合中。

1.8使用的是2次幂扩容，即每次扩容为原来长度的2倍，索引元素的位置要么在原位置，要么在

 原位置，要么在原位置+原size,只需要看看原hash值新增的那个bit位是0还是1，是0的话索引不变，是1的话索引位置为原位置+原size。

十一、删除元素

        HashMap删除元素首先要找到桶的位置，如果是链表进行链表遍历，找到需要删除的元素进行删除；如果是红黑树，也是进行树的遍历，找到元素后进行删除，然后进行平衡调节，当红黑树结点小于6时，转化成链表。

    public V remove(Object key) {
        Node<K,V> e;
        // 删除成功则返回被删除的value
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }    

    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        // 查找目标节点
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    // 红黑树
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    // 链表
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            // 删除逻辑
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    // 红黑树删除逻辑，红黑树的删除后平衡比较复杂，后续分析
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                else if (node == p)
                    tab[index] = node.next;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

十二、查找元素

        首先通过key找到索引位置，再根据节点性质遍历，找到目标元素返回。

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : 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 ((tab = table) != null && (n = tab.length) > 0 &&
     (first = tab[(n - 1) & hash]) != null) {
      //根据key计算的索引检查第一个索引
      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;
 }

十三、面试题 

         1、JDK1.8 为什么要引入红黑树？

        主要是为了解决hash冲突带来的链表过长问题，将可能出现的O(n)级别查找，优化为红黑树的O(logn)级别查找。

        2、是什么时候用链表，什么时候用红黑树？

        插入：当出现了哈希冲突，默认使用链表，当链表长度达到9（也就是大于8）的时候，此时判断capacity和64的关系，如果是capacity>=64,则进行链表转红黑树，如果是capacity<64，此时优先对数组进行扩容。

        移除：当红黑树的个数小于6个的时候，此时触发红黑树转链表。

        3、为什么链表转红黑树的阈值是8？

        阈值8是根据泊松分布实验扥出的一个在时间和空间上的平衡点。

        红黑树节点大小约为链表节点的2倍，在节点太少时，红黑树的查找性能优势并不明显，付出2倍空间的代价不值得，理想情况下，使用随机的哈希码，节点分布在 hash 桶中的频率遵循泊松分布，按照泊松分布的公式计算，链表中节点个数为8时的概率为 0.00000006，这个概率足够低了，并且到8个节点时，红黑树的性能优势也会开始展现出来，因此8是一个较合理的数字。 

         4、为什么转回链表的阈值是6而不是8呢？

        如果阈值设置为8，那么可能会出现链表和红黑树之间频繁的转换，这样对我们的性能影响是非常大的。

        5、HashMap的初始容量是多少？HashMap的容量有什么限制？

        默认的初始容量是16，HashMap的容量必须是2的n次方，当传入一个初始容量的时候，HashMap会对容量进行修改，将传入容量值修改为大于该值的最近的2的n次方的值。

        6、HashMap的容量必须是2的n次方，这是为什么？

        根据hash值计算下标时，在table的长度为2的n次方的时候，能有效减少哈希冲突，使散列分布更均匀。简单来说就是为了增加length-1中1的位数，这样才能让所有下标都参与到散列分布。

        7、为什么负载因子默认为0.75？

        这个因子也是在时间和空间上的权衡点，大于0.75的时候，能够减少空间成本，但是冲突就会变多，查找效率自然会下降，小于0.75的时候，冲突会有效减少，但是空间成本就会上升。

        8.HashMap的插入流程是怎么样的？

        

        9、hash()是怎么实现的？

         共分为三步：判断key是否为null，取hashCode低16位和hashCode的高16位，进行异或运算返回

        10、为什么高16位参与运算？

        有效减少哈希冲突。

        11、说说扩容流程？

        12、JDK1.8主要进行了哪些优化呢？

        （1）、数据结构的优化，引入红黑树后有效减少hash冲突，降低查找复杂度。

        （2）、优化hash()，引入高16进行运算，增强散列分布。

        （3）、链表的头插变尾插，避免了并发下的死循环问题。

        （4）、扩容时计算节点在新表的索引位置方式从“h & (length-1)”改成使用“hash & oldCap==0”,来判断是否需要修改索引，设计的更巧妙优雅。