HashMap常见面试题总结（持续更新）

个人理解，如有错误，欢迎指正

1.HashMap的原理

HashMap是一种集合，继承AbstractMap<K,V>类，实现了Map<K,V>接口，它的底层是由数组和链表组成的，存储的元素为Entry<K,V>键值对。一个HashMap只允许一个Key为null值，但是允许多个Value为null值。它存储元素主要依赖于存储对象Key的Hashcode值，通过对Hashcode进行取高位运算然后与自身进行异或（为了尽可能的使散列值分散），再通过对数组长度进行取模得到索引位置，得到索引位置后判断是否为null值，如果是null就直接插入，如果不是就遍历链表，看是否存在相同的Key值，存在就更新Value值，不存在就从头部插入新元素，插入后还需判断是否结点数超过8个，超过8个需要转换为红黑树。

2.如何解决Hash冲突

java中解决Hash冲突是依赖于拉链法。得到索引位置后，如果这时候已经有结点存在，就需要遍历当前索引的链表，看是否存在相同的Key值，存在就更新Value值，不存在就从头部插入新元素，插入后还需判断是否结点数超过8个，超过8个需要转换为红黑树。
其他解决Hash冲突的方法还有开放定址法。

3.HashMap的缺点

HashMap主要是依赖于Hashcode值，它在提供超快速的查询效率时也存在一些不好的地方。如果定义一个新类时重新的Hashcode方法不恰当就很容易产生以下两种情况。

• 所有元素的Hashcode值都一样，这就导致了对应索引处的链表非常的长，查询效率慢，但是后面引进的红黑树针对这种现象提供了很大的优化。
• 所有元素Hashcode对应的索引值都不相同，这就导致HashMap很容易扩容，造成内存的浪费和进行扩容操作时的不必要开销。

HashMap需要额外计算一次Hash值，如果一开始HashMap的容器大小制定不合适，resize操作会使它多次额外计算Hash值。

4.HashMap的resize方法了解吗，说一说它的作用

这个方法就是在HashMap容量不够的时候进行扩容的。

• HashMap在创建时的Node<K,V>默认的初始容量为16，但这并不意味着一创建Map对象就有这样一个16大小的哈希桶数组，它会在第一个put方法的时候进行判断，下面我们来看看put方法的源码

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

它调用了一个putVal方法，参数是key的hash，key， 对象的value，以及两个Boolean判断，要弄清他们是什么东西让我们接着看看这个putVal方法是什么东西？

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                  boolean evict) {
     ！！（对传入两个参数的注解）
   // * @param onlyIfAbsent if true, don't change existing value
    //* @param evict if false, the table is in creation mode.
       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);
   /*
   一些关于判断对象索引以及如何处理Hash冲突的部分我们省去，主要看和resize相关的部分就可以了
   */
       if (++size > threshold)
           resize();
       afterNodeInsertion(evict);
       return null;
   }

这里的putVal源码只展示了和resize相关的部分，首先他会先判断Node<K,V> tab数组是否为null，这个判断是什么意思呢？
就是说HashMap在添加元素之前也不知道你的tab数组是否存在？如果存在就接着往下执行，如果不存在就执行一个初始化操作，令tab = resize（），n = resize（）的长度。终于看到resize方法了，让我们接着往下看看它到底怎么进行这个初始化操作的吧。

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = 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)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            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;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
      	//	一些关于有元素时，resize进行重排的代码
      	//  这里就不进行分析了，一会接着讲
        }
        return newTab;
    }

我们可以看到最后是返回了一个newTab这样一个对象，我们一起按照上面源码的逻辑看看如果传入的是一个为null的oldTable会是上面流程。

首先判断oldTab 为null吗，为null把oldCap赋值为0，接着赋值oldThr为threshold，然后初始化两个newCap, newThr = 0。

        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;

很简单的步骤，这里唯一的疑惑就是threshold这个东西哪里来的？事实上我在翻查源码后发现HashMap有这样一个构造方法。

public HashMap() {
        // all other fields defaulted
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

这里的loadFactor已经被赋值为默认的负载因子了，并且它说所有的其他成员变量已经被初始化了。

all other fields defaulted

翻看成员变量发现，在一开始构造HashMap是就有一个成员变量threshold，没有赋值，这意味着它初始值为0

    int threshold;//没有赋值，这意味着它初始值为0

让我们这接着往下看resize方法

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = 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)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }

首先它判断if (oldCap > 0) ，我们这里是初始化的第一次put，它肯定是0的。

我们接着看下个条件else if (oldThr > 0)，它问我们oldThr是否大于0，之前通过分析得知默认threshold为0，因此这里不满足条件。

接着看下一个else ，到这里就肯定要执行了，实现了一个默认赋值的操作，并且

• newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY) 这里就明确了需要resize的边界条件

else {               // zero initial threshold signifies using defaults
            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;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
       	return newTab;

else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;

这里的if (newThr == 0)是为了给下面条件的newThr做初始化，我们这里用不上一次直接看后面的代码

 if (newThr == 0) {
       //省略
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        return newTab;        

把newThr赋值个threshold，在创建了一个类型为Node<K,V>的数组，最后返回newTab，这样就得到了一个初始化的哈希桶数组。
未完待续…