JDK1.8-结合JAVA面试问题与源码理解HashMap原理

HashMap介绍

简单来说，HashMap是JAVA中实现key-value存储的一种数据结构，允许null的value和null的key,是线程不安全的
.

问：new HashMap()和new HashMap(16)有什么区别

new HashMap()：不会初始化hashMap存储数据的table数组，不会去计算table数组的大小，使用默认的加载因子（即容量达到多少时进行扩容：默认0.75（即达到容量的75%时对map进行扩容））
new HashMap(16)：不会初始化hashMap存储数据的table数组，但是会去计算table数组的大小

问：new HashMap(10)时，HashMap的初始化容量会是多少

如果不做put操作会是0，使用put操作时初始容量会是16，由上面问题可知，构造时不会对HashMap进行初始化操作,只会计算下一次扩容需要的大小，计算扩容大小的tableSizeFor方法如下

问：HashMap中数据存在什么对象，什么时候初始化

HashMap中存储数据的对象：Node<K,V>[] table, Node节点实现 Map.Entry<K,V> 接口。


table初始化是在第一次put操作的时候进行的。

问：HashMap中的数据是怎么存储的

HashMap是通过key-value存储数据的，内部的数据结构：数组+链表+红黑树，通过hash算法计算key值的hash值并取模操作获取数据存储数组下标，再通过key值的比较找到指定位置进行存储。

链表和红黑数会根据链表和树节点的数量自动转换：
链表转红黑树：TREEIFY_THRESHOLD为静态常量=8

红黑树转链表：

结构如下图

问：HashMap中是如何自动扩容的

自动扩容操作是发生在put操作的时候，在数据put到HashMap之后，如果table中有效数据大小（即size）> table.length*loadFactor(加载因子)时会进行自动扩容

扩容步骤如下
1.获取该次扩容的大小，并计算下一次自动扩容的大小
2.新建一个扩容后的table数组
3.将原table中的数据复制到新table中（其中包括红黑树遍历和链表遍历）
代码具体操作如下：比较复杂，记住上面三步即可

/**
 * map扩容
 * 将原table中的数据复制到扩容后table中并返回
 * 扩容操作步骤
 * 1.获取该次扩容的大小，并计算下一次自动扩容的大小
 * 2.新建一个扩容后的table数组
 * 3.将原table中的数据复制到新table中
 */
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    //原table的大小
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //该次扩容的目标大小
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        //原始的容量超过最大值
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            //新的扩容大小 oldThr*2
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 将新数组的容量设置为需要扩容的容量
        //获取该次扩容的大小
        newCap = oldThr;
    else {
        //不指定参数第一次初始化使用默认值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //设置容器下一次扩容的大小
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    
    //新建一个扩容后的table数组
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //新table容器
    table = newTab;
    if (oldTab != null) {
        //将原table中的数据 复制到 新的table中 遍历数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //没有子节点直接存到新table中
                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 {
                        //将链结构的所有数据复制到新table中
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

问：什么是hash冲突，为什么要避免hash冲突，怎样能够减少hash冲突

HashMap存入数据时是对key值进行hash取模计算，获取数据存储的下标位置，当不同的key进行hash取模计算是获得的下标一致，即发生了hash冲突。
(n - 1) & hash：n为table的容量，与运算的值<n-1

当发生hash冲突的时候，插入和查询数据都需要遍历链表或红黑树，会影响HashMap的性能，从代码中可以看出，hash冲突时会发生链表遍历及链表与红黑树转换，降低插叙及查询效率。

在构建HashMap时指定loadFactor（0<loadFactor<=1），loadFactor越小，发生hash冲突的几率越低，但内存的利用率也越低,hash算法复杂度越高，hash冲突的几率越低。