HashMap面试点提点

Java 容器

1. 集合和数组的区别

● 数组是固定长度的，集合可变长度；
● 数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型；
● 数据存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型；

如何理解集合存储的对象可以是不同数据类型：
其实，不同的数据类型根本上都继承于Object类，本质上还是同一类型的元素。

List<Object> list = new ArrayList<>();
list.add("abc");
list.add(132);

2. Java集合的快速失败机制"fail-fast" ?

是Java集合的一重错误检测机制，当多个线程对集合进行结构上的改变操作时，有可能触发fail-fast机制

例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。

原因：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
解决方法：

1. 在遍历过程中，所有涉及到改变modCount值的所有地方全部加上sync

2. 使用CopyOnWriteArrayList来替代ArrayList

3. 如何边遍历边移除Collection中的元素？
   唯一正确的方式是使用Iterator.remove() 方法

Iterator<Integer> it = list.iterator();
while(it.hasNext()){
   *// do something*
   it.remove();   // 错误的删除方式为  list.remove(i);
}

4. ArrayList 和 Vector 的区别？

• 这两个类都实现了 List 接口（List 接口继承了 Collection 接口），他们都是有序集合
  ○ 线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。
  ○ 性能：ArrayList 在性能方面要优于 Vector。
  ○ 扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。

● Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。

● Arraylist不是同步的，所以在不需要保证线程安全时时建议使用Arraylist。

5. 为什么ArrayList的elementData加上了transient修饰？

public class ArrayList<E> extends AbstractList<E>
       implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   	transient Object[] elementData; 
       // non-private to simplify nested class access

可以看到 ArrayList 实现了 Serializable 接口，这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化，重写了 writeObject 实现：

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{

        int expectedModCount = modCount;
        s.defaultWriteObject();

        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

每次序列化时，先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍历 elementData，只序列化已存入的元素，这样既加快了序列化的速度，又减小了序列化之后的文件大小。

6. 简述一下HashSet底层原理？

HashSet是基于HashMap实现的，HashSet的值存放于HashMap的Key中，HashMap的value统一为present(new Object()) ，因此HashSet的实现比较简单，相关HashSet的操作都是基于调用底层HashMap的相关方法实现的，HashSet不允许重复的值。

	private transient HashMap<E,Object> map;
	// Dummy value to associate with an Object in the backing Map
	private static final Object PRESENT = new Object();

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

7. HashSet如何检查重复？

HashSet 的add()方法实际上调用的 HashMap的 put() 方法

HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key，并且在HashMap中如果K/V相同时，会用新的V覆盖掉旧的V，然后返回旧的V。所以不会重复（ HashMap 比较key是否相等是先比较hashcode 再比较equals ）。

8. HashMap中的hash值怎么计算的？

    static final int hash(Object key) {
        int h;  //h为key计算得到的hashcode值    int位4字节一共32位
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        /*
        h >>> 16    h向右移16位，高16位补0
        ^ 异或操作  相同取0， 不同取1       
        0 0-> 0  
        0 1-> 1 
        1 0-> 1
        1 1-> 0
        h ^ (h >>> 16) 即h的低16位与高16位进行异或操作得到一个新的hash值
        
        但是此hash并不是最终得到的hash值
        后续还会对此hash进行另外的操作
        */
        i = (n - 1) & hash
        /*
        n为hashmap的容量，默认初始容量为16     hash为上述 hash()后得到的值
        n - 1  即 16-1=15(此处以16举例)  15的二进制刚好为 1111
        然后与hash进行与操作，得到hash的低四位作为该key在HashMap中的位置
        此处也可以理解为什么HashMap为什么每次都是扩容1倍  利于计算hash值
        */
    }

9. HashMap的实现原理？

HashMap是基于hash算法实现的，数据结构包括数组+链表+红黑树

1. 当往HashMap中put元素时，对key进行hash计算出当前元素在数组中对应的下标
2. 存储时，如果出现hash值相同的key，此时有两种情况。
   a. 如果key相同，则覆盖原始值，并返回旧值
   b. 如果key不同，即hash冲突，则将当前的键值对放入链表中
3. 获取值时，直接找到key的hash值对应的下标，在链表中依次查找得到该value

HashMap在jdk8中引入了红黑树，当链表的节点大于8个时，链表自动转换为一颗红黑树，存在一定内存消耗，当链表的节点小于6个时，红黑树自动转换为链表。

jdk7中的hash有9此扰动，4次位运算和5次异或运算，jdk8中两次扰动，1次位运算1次异或运算

10. HashMap的put操作

● 判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
● 根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
● 判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
● 判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向5；
● 遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
● 插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。

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

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

//实现Map.put和相关方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 步骤①：tab为空则创建 
    // table未初始化或者长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 步骤②：计算index索引，并对null做处理  
    // (n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 步骤③：节点key存在，直接覆盖value 
        // 比较桶中第一个元素(数组中的结点)的hash值是否相等，key是否相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;
        // 步骤④：判断该链为红黑树 
        // hash值不相等，即key不相等；为红黑树结点
        // 如果当前元素类型为TreeNode，表示为红黑树，putTreeVal返回待存放的node, e可能为null
        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值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;
                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }
        //判断当前的key已经存在的情况下，再来一个相同的hash值、key值时，返回新来的value这个值
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 步骤⑥：超过最大容量就扩容 
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

11. 简述红黑树

红黑树是一种自平衡二叉排序树，每个节点都有颜色，颜色为红色或者黑色，满足以下特性：

1. 节点是红色或黑色
2. 根节点是黑色
3. 所有叶子节点都是黑色的空节点(叶子节点是NIL节点或NULL节点)
4. 每个红色节点的两个子节点都是黑色节点，即不能出现连续两个红色节点
5. 从任一节点到其每个叶子节点的所有路径都包含相同数目的黑色节点

红黑树的三种操作：

1. 左旋 同二叉平衡树的左旋
2. 右旋 同二叉平衡树的右旋，与左旋互逆
3. 变色
   变色操作需要按照第五条规则进行，按照规则将节点的颜色由红变黑或者由黑变红

向红黑树中新插入的节点都要默认设置为红色，如果插入的节点为黑色，特性5必然被打破，此时必须进行变色操作，将新节点设置为红色，可以降低破坏红黑树特性的可能。

若30的父节点为红色还需要继续变色直到满足条件为止。删除操作类似。

详细跳转----> 红黑树

13. HashMap扩容操作是怎么实现的？

在jdk8中，resize方法是在HashMap中的键值对大于阈值时触发进行扩容，每次扩展两倍
扩展后的Node对象的位置要么在原位置，要么移动到原始位置+增加的数组大小这个位置上
这个扩展后的Node对象的位置如何理解要么在原位置或者原始位置+增加的数组大小这个位置上呢？
首先知道一点，HashMap的扩容每次都是两倍，以默认初始16举例，扩容后为32
而每个key在计算hash时会有 (n - 1) & hash 15的二进制为 1111， 31的二进制为11111
即 扩容前得到的是hash的低4位，扩容后得到的是hash的低5位，多的那一位是0，则在原位置不变，多的那一位是1，则移动到原始位置+增加的数组大小这个位置上

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;//oldTab指向hash桶数组
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {//如果oldCap不为空的话，就是hash桶数组不为空
        if (oldCap >= MAXIMUM_CAPACITY) {//如果大于最大容量了，就赋值为整数最大的阀值
            threshold = Integer.MAX_VALUE;
            return oldTab;//返回
        }//如果当前hash桶数组的长度在扩容后仍然小于最大容量 并且oldCap大于默认值16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold 双倍扩容阀值threshold
    }
    // 旧的容量为0，但threshold大于零，代表有参构造有cap传入，threshold已经被初始化成最小2的n次幂
    // 直接将该值赋给新的容量
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    // 无参构造创建的map，给出默认容量和threshold 16, 16*0.75
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 新的threshold = 新的cap * 0.75
    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];//新建hash桶数组
    table = newTab;//将新数组的值复制给旧的hash桶数组
    // 如果原先的数组没有初始化，那么resize的初始化工作到此结束，否则进入扩容元素重排逻辑，使其均匀的分散
    if (oldTab != null) {
        // 遍历新数组的所有桶下标
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                // 旧数组的桶下标赋给临时变量e，并且解除旧数组中的引用，否则就数组无法被GC回收
                oldTab[j] = null;
                // 如果e.next==null，代表桶中就一个元素，不存在链表或者红黑树
                if (e.next == null)
                    // 用同样的hash映射算法把该元素加入新的数组
                    newTab[e.hash & (newCap - 1)] = e;
                // 如果e是TreeNode并且e.next!=null，那么处理树中元素的重排
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                // e是链表的头并且e.next!=null，那么处理链表中元素重排
                else { // preserve order
                    // loHead,loTail 代表扩容后不用变换下标，见注1
                    Node<K,V> loHead = null, loTail = null;
                    // hiHead,hiTail 代表扩容后变换下标，见注1
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 遍历链表
                    do {             
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                // 初始化head指向链表当前元素e，e不一定是链表的第一个元素，初始化后loHead
                                // 代表下标保持不变的链表的头元素
                                loHead = e;
                            else                                
                                // loTail.next指向当前e
                                loTail.next = e;
                            // loTail指向当前的元素e
                            // 初始化后，loTail和loHead指向相同的内存，所以当loTail.next指向下一个元素时，
                            // 底层数组中的元素的next引用也相应发生变化，造成lowHead.next.next.....
                            // 跟随loTail同步，使得lowHead可以链接到所有属于该链表的元素。
                            loTail = e;                           
                        }
                        else {
                            if (hiTail == null)
                                // 初始化head指向链表当前元素e, 初始化后hiHead代表下标更改的链表头元素
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 遍历结束, 将tail指向null，并把链表头放入新数组的相应下标，形成新的映射。
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

14. 为什么HashMap中String、Integer这样的包装类适合作为Key？

● String和包装类的特性能够保证Hash值的不可更改和计算准确性，能够有效的减少Hash碰撞
○ 都是final类型，即不可变性，保证key的不可更改，同时hashcode值可以被缓存，提高性能。
○ 内部重写了equals(),hashCode()方法，遵守了HashMap内部的规范，不容易出现Hash计算错误的情况

15. HashMap为什么不直接使用hashCode()返回值作为table的下标？

hashcode方法返回的是int整数类型，范围很大，而HashMap的初始容量范围是16，并且设备也很难提供这么多的存储空间，直接使用hashCode方法返回值可能不在数组范围内。解决办法上述已经说了。

16. 对于HashMap的构造方法传入的一个初始容量是如何变成2的n次方的？

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;
    }

假设传入的值为20   其二进制为 10100
    n = cap - 1             10011
    n >>> 1					01001
    n = n | n >>> 1         10011 | 01001  = 11011
    n = n | n >>> 2			11011 | 00110  = 11111
    n = n | n >>> 4			11111 | 00001  = 11111
    ...
    其实不难看出对于一个int类型 不断移位后其结果都是 将第一个出现的 1 后面的低位全部补为1
    在return中， 会得到 n + 1  其结果为  11111 + 1 = 100000  即 32   最后的容量即为32
    
    那为什么要在开始时要有  cap - 1 呢？
    实际上是为了处理  输入进来的 cap 是 2 的 n 次幂时，最后的结果仍然时输入值，如果不减 1 ，会导致容量会扩大一倍。如果输入的数不是2的n次幂，减一操作可有可无，不影响最后的值