HashMap笔记

HashMap

介绍

HashMap是一个以键值对形式保存数据的结构，实现了Map接口，可以接受null的键值，内部没有做同步处理，内部将key的hash值，key，hash，next(下一个结点)，包裹在一个对象中进行保存；

HashMap的工作原理

我们使用put(key,value)方法往HashMap中添加元素时，先计算得到key的Hash值，然后通过Key高16位与低16位相异或（高16位不变），然后与数组大小-1相与，得到了该元素在数组中的位置；

如果数组中该位置为空，则直接放入，如果不为空（出现了Hash冲突），则接到以数组该位置为链头的链表中；

在Java8中，链表的长度超过8，则使用红黑树来替换链表，以提高查找速度；

使用get从HashMap中读取元素时，先通过同样的方法计算Key在数组中的下标，再通过key的equals()方法来查找对应的元素；如果该位置是一个链表，则查找的速度为O(n)，如果该位置是红黑树，查找的时间复杂度为O(logN)；

如果HashMap的数组使用量超过了一个阈值（负载因子，默认0.75），HashMap将会resize，即重新开辟一个原来数组长度两倍的HashMap，并重新计算位置；

相关问题

1. 为什么在resize的时候是扩展为原数组大小的两倍？

   扩展为两倍是为了方便重新确定元素在数组中的位置，当扩展为两倍时，数组的大小在二进制中就相当于在高位多了一位，重新得到的位置要不就是在原位置，要不就是原位置加上原数组大小的位置；

   因为index的计算是通过元素的hash与数组大小-1相与，数组大小-1在高位多了一位，则只需要在原来的hash的高位多取一位就是元素的index，这一位有可能是0，有可能是1，是0的时候元素的位置不变，是1的时候位置相当于加了原始数组大小的位置；

   同时可以认为新增的那一位的值是随机的，也就是可以均匀地把元素分布在新的数组中；

   举例：

   数组的大小是16： 0000 0000 0000 0000 0000 0000 0001 0000

   则数组大小减一是：0000 0000 0000 0000 0000 0000 0000 1111

   扩容后数组大小是：0000 0000 0000 0000 0000 0000 0010 0000

   数组大小减一是： 0000 0000 0000 0000 0000 0000 0001 1111

   假设元素的hash是：1111 1111 1111 1111 0000 1111 0001 0101

   原始的元素位置为：0101，即为5

   扩容后的位置是：1 0101，为5 + 16 = 21

   以下是扩容的代码（仅截取了为链表的部分）：

   if (oldTab != null) {
       for (int j = 0; j < oldCap; ++j) {
           Node<K,V> 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<K,V>)e).split(this, newTab, j, oldCap);
               else { // preserve order
                   //将该位置的元素分成两部分，一部分为增加的一位是1的(hi)，一部分为增加的一位是0的(lo)
                   Node<K,V> loHead = null, loTail = null;
                   Node<K,V> hiHead = null, hiTail = null;
                   Node<K,V> next;
                   do {
                       next = e.next;   // mark
                       //增加的一位是0
                       if ((e.hash & oldCap) == 0) {
                           //构造链表
                           if (loTail == null)
                               loHead = e;
                           else
                               loTail.next = e;
                           loTail = e;
                       }
                       //增加的一位是1
                       else {
                           if (hiTail == null)
                               hiHead = e;
                           else
                               hiTail.next = e;
                           hiTail = e;
                       }
                   } while ((e = next) != null);
                   //对增加的一位是0的元素进行处理
                   if (loTail != null) {
                       loTail.next = null;
                       //放置的位置为原始位置
                       newTab[j] = loHead;
                   }
                   //对增加的一位是1的元素进行处理
                   if (hiTail != null) {
                       hiTail.next = null;
                       //放置的位置为原始位置加上原始数组大小
                       newTab[j + oldCap] = hiHead;
                   }
               }
           }
       }
   }
   

2. 在计算index时为什么要高16位与低16位异或？

   设计者为了提高在计算index时的效率，没有采用取余（%）的方式计算index，而是采用了位运算，通过hash与数组大小-1（数组大小总是为 ）相与(&)得到；

   但是这样在数组较小的情况下容易产生Hash冲突，数组大小为16时，参与运算的只有hash的末尾4位，一共就只有15个值；

   所以在综合考虑了速度和质量的情况下让高16位也参与运算，在保证效率的同时一定程度上降低了Hash冲突出现的可能性；

3. HashMap是线程安全的吗？

   不是，在两个线程同时put时会出现线程A的元素覆盖线程B元素的问题;

   假设根据线程A，B想要插入的元素的Key，计算得到的在数组中的index相同；A线程先拿到了在那个index的链尾元素的引用，这时线程A的时间片用完；线程B执行，并成功地插入了元素，之后线程A继续执行，于是将链尾元素的引用指向了自己的元素，线程B的元素就被抛弃掉了，造成了线程A对线程B结果的覆盖；