Java中的集合类——HashMap

HashMap实现原理

JDK1.7下的HashMap

1、简介

（1）在hash表中进行添加、删除、查找等操作性能很高，不考虑hash冲突的情况下仅需一次定位即可完成，时间复杂度为O(1)。
（2）hash表的主干就是数组。
（3）当我们要新增或查找某个元素，我们通过把当前元素的关键字通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。即：存储位置 = f(关键字)

（4）哈希冲突：当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀，但再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。HashMap即是采用了链地址法处理hash冲突，也就是数组+链表的方式。
（5）HashMap内部实现：

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
（6）在常规构造器中，没有为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组。

2、HashMap中查找元素位置的操作

（1）寻找HashMap中位置的流程：

（2）为何HashMap的数组长度一定是2的次幂？
在HashMap的扩容方法resize方法中，其中的transfer方法将老数组中的数据逐个链表地遍历，扔到新的扩容后的数组中，我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后，再通过和 length-1进行位运算得到最终数组索引位置。
比如length=16时，length-1就是15，即01111，扩容后length=32，length-1就是31即011111，这样在调用h&(length-1)方法时只要比较多出的那一位原本对应的h值的位是否为1就能判断其是否需要重新分配位置

第二个作用就是若数组长度保持2的次幂，length-1的低位都为1，会使得获得的数组索引index更加均匀，比如：

（3）为什么重写equals时也要同时覆盖hashCode？
默认情况下对象的hashCode即对象的存储地址，故即使重写了equals方法使两个对象判断为相等其hashCode依旧不相同。
在get和put哈希表元素时会取出key的hashCode进行hash操作并调用indexFor方法，若未重写hashCode方法，会导致未定位到一个正确的数组位置而返回逻辑的错误。
（4）hash方法中需要做四次异或操作，目的就是最大程度打乱key的位置，减少hash冲突。

3、扩容操作

（1）使用一个容量更大的数组newTable来代替已有的容量小的数组，使用transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里，拷贝结束后将newTable赋值给table。
（2）JDK1.7中会遍历所有table桶位置的链表元素并将其插入到newTable的适当位置。（JDK1.8中作出优化）。

JDK1.8下的HashMap

1、扰动函数

与JDK1.7的四次异或不同，JDK1.8只做一次16位右位移异或混合：key.hashCode() ^ (h >>> 16)
若只取最后几位的话碰撞会很严重，混合原始哈希码的高位和低位，以此来加大低位的随机性。

2、HashMap的扩容

（1）Node[] table，即hash桶数组的初始长度为16，Load factor为负载因子(默认值是0.75)。threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。（Load factor的值可以大于1）。
（2）JDK1.8中新增：当链表长度太大（超过8时），链表就转化成红黑树，利用红黑树快速增删改查的特点提高性能。
（3）JDK1.8中对transfer的优化：由于我们使用的是2次幂的扩展，所以元素的位置要么是在原位置，要么是在原位置移动2次幂的位置。

因此我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”。

3、put原理

（1）对key的hashCode()做hash，然后再计算index;
（2）如果没碰撞直接放到bucket里；
（3）如果碰撞了，以链表的形式存在buckets后；
（4）如果碰撞导致链表过长(大于等于TREEIFY_THRESHOLD)，就把链表转换成红黑树；
（5）如果节点已经存在就替换old value(保证key的唯一性)
（6）如果bucket满了(超过load factor*current capacity)，就要resize。

4、get原理

（1）bucket里的第一个节点，直接命中.
（2）如果有冲突，则通过key.equals(k)去查找对应的entry ；若为树，则在树中通过key.equals(k)查找，O(logn)； 若为链表，则在链表中通过key.equals(k)查找，O(n)。

HashMap常见问题

什么时候会使用HashMap？他有什么特点？

是基于Map接口的实现，存储键值对时，它可以接收null的键值，是非同步的，HashMap存储着Entry(hash, key, value, next)对象。

你知道HashMap的工作原理吗？

通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K/V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)。获取对象时，我们将K传给get，它调用hashCode计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在Java 8中，如果一个bucket中碰撞冲突的元素超过某个限制(默认是8)，则使用红黑树来替换链表，从而提高速度。

你知道get和put的原理吗？equals()和hashCode()的都有什么作用？

通过对key的hashCode()进行hashing，并计算下标( n-1 & hash)，从而获得buckets的位置。如果产生碰撞，则利用key.equals()方法去链表或树中去查找对应的节点。

你知道hash的实现吗？为什么要这样实现？

在Java 1.8的实现中，是通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的，这么做可以在bucket的n比较小的时候，也能保证考虑到高低bit都参与到hash的计算中，同时不会有太大的开销。

如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

如果超过了负载因子(默认0.75)，则会重新resize一个原来长度两倍的HashMap，并且重新调用hash方法。
关于Java集合的小抄中是这样描述的： 以Entry[]数组实现的哈希桶数组，用Key的哈希值取模桶数组的大小可得到数组下标。
插入元素时，如果两条Key落在同一个桶(比如哈希值1和17取模16后都属于第一个哈希桶)，Entry用一个next属性实现多个Entry以单向链表存放，后入桶的Entry将next指向桶当前的Entry。
查找哈希值为17的key时，先定位到第一个哈希桶，然后以链表遍历桶里所有元素，逐个比较其key值。
当Entry数量达到桶数量的75%时，会成倍扩容桶数组，并重新分配所有原来的Entry，所以这里也最好有个预估值。
取模用位运算(hash & (arrayLength-1))会比较快，所以数组的大小永远是2的N次方， 你随便给一个初始值比如17会转为32。默认第一次放入元素时的初始值是16。
iterator()时顺着哈希桶数组来遍历，看起来是个乱序。

当两个对象的hashcode相同会发生什么

因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。

如果两个键的hashcode相同，你如何获取值对象？

找到bucket位置之后，会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。因此，设计HashMap的key类型时，如果使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择

如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？

默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来HashMap大小的两倍的bucket数组，来重新调整map的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因为它调用hash方法找到新的bucket位置。

你了解重新调整HashMap大小存在什么问题吗

当重新调整HashMap大小的时候，确实存在条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在链表中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在链表的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。因此在并发环境下，我们使用CurrentHashMap来替代HashMap。

为什么String, Interger这样的wrapper类适合作为键？

因为String是不可变的，也是final的，而且已经重写了equals()和hashCode()方法了。其他的wrapper类也有这个特点。不可变性是必要的，因为为了要计算hashCode()，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode的话，那么就不能从HashMap中找到你想要的对象。不可变性还有其他的优点如线程安全。如果你可以仅仅通过将某个field声明成final就能保证hashCode是不变的，那么请这么做吧。因为获取对象的时候要用到equals()和hashCode()方法，那么键对象正确的重写这两个方法是非常重要的。如果两个不相等的对象返回不同的hashcode的话，那么碰撞的几率就会小些，这样就能提高HashMap的性能。