集合面试题之双列集合Map

一.了解Map集合吗？Map集合都有哪些实现

HashMap 、HashTable、    LinkedHashMap 、TreeMap、   ConcurrentHashMap

HashMap底层数据结构是哈希表，所以其特点是元素无序且唯一（自定义对象需要重写hashCode和equals方法保证他的唯一性）

Hashtable它和HashMap类很相似，但是它支持同步，Hashtable在哈希表中存储键/值对，当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

LinkedHashMap 是 Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

TreeMap底层数据结构是红黑树，可以对元素进行排序

ConcurrentHashMap是Java并发包中提供的一个线程安全且高效的HashMap实现

 

因为Map集合也是一个接口，所以利用抽象类多态实现对象的创建，其中的String泛型指的就是键，Student泛型指的就是值，通常统称为一个键值对。

Map集合的数据结构之和键有关，和值无关。

二.HashMap和HashTable之间的区别
1.HashMap：底层基于数组+单向链表（红黑树），非线程安全，默认容量为16，允许有空的键和值
数组：Node<K,V> [] table ，每一个元素都是一个Node
单向链表：Node<K,V> next，当发生Hash碰撞，会追加链表，当链表长度大于8，那就转换为红黑树

 

 

2.HashTable:底层基于哈希表实现，线程是安全的，默认容量为11，不允许有空的键和值

 

 

三.hashCode()和equals()方法使用场景
hashCode():顶级父类Object当中的方法，返回值类型为int类型的值，根据一定的规则（存储地址，字段，长度等等）生成一个数组，数据保存的就是Hash值
equals():顶级类Object中的方法，根据一定的比较规则，判断对象是否一致，底层一般逻辑：
1.判断两个对象的内存地址是否一样
2.非空判断和Class类型判断
3.强转
4.对象中的字段一一匹配


四.HashMap和TreeMap应该如何选择
HashMap：底层采用数组+链表（红黑树）结构，可以实现快速的存储和检索，但是数据是无序的，适用于在Map当中插入删除或者获取元素

TreeMap: 存储结构是一个平衡二叉树，具体实现方式为红黑树，默认采用自然排序，可以自定义排序规则，但是需要实现Comparator接口
能够便捷的实现内部元素的各种排序，但是性能比HashMap差，适用于按照自然排序和自定义排序规则



五.Set和Map的关系
Set核心就是保存不重复的元素，存储一组唯一的对象
Set当中每一种实现都对应Map
HashSet对应的HashMap，TreeSet对应的TreeMap

 

六.常见的Map排序规则
按照添加规则使用LinkedHashMap，按照自然排序或者自定义规则排序可以采用TreeMap

七.如何保证Map线程安全
多线程环境下，可以使用concurrent包下有一个ConcurrentHashMap或者是使用Collections.synchronizedList(new HashMap<K,V>());

ConcurrentHashMap保证线程安全，效率比HashTable高，采分段锁


八.HashMap底层源码剖析
1.介绍HashMap底层用到的数据结构以及什么是Hash碰撞？解决办法有哪一些

1.1HashMap底层的结构

在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。

HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

 

 

从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。

1.2能够解释一下什么是Hash碰撞？解决办法有哪一些
不同的key可能会产生相同的Hash值
解决Hash碰撞的办法：链表法，再哈希法
HashMap当中采用链表发，在ConcurrentHashMap当中采用再哈希法

2.为什么采用红黑树，并且为什么临界值为8

2.1为什么采用红黑树

在平常我们用HashMap的时候，HashMap里面存储的key是具有良好的hash算法的key（比如String、Integer等包装类），冲突几率自然微乎其微，

此时链表几乎不会转化为红黑树，但是当key为我们自定义的对象时，我们可能采用了不好的hash算法，

使HashMap中key的冲突率极高，但是这时HashMap为了保证高速的查找效率，就引入了红黑树来优化查询了。

2.2为什么临界值为8

因为当桶中结点个数为8时，出现的几率是亿分之6的，因此常见的情况是桶中个数小于8的情况，此时链表的查询性能和红黑树相差不多，因为转化为树还需要时间和空间，所以此时没有转化成树的必要。

3.put和get底层源码的核心流程

3.1put流程

public V put(K key, V value) {
                    //计算key的Hash值，然后将Hash值以及key值本身和Value传递到putval方法当中
                    return putVal(hash(key), key, value, false, true);
                }
                
                final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
                    Node<K,V>[] tab; Node<K,V> p; int n, i;
                    //判断当前数组是否为空，如果为空要进行第一次扩容
                    if ((tab = table) == null || (n = tab.length) == 0)    
                        //扩容后将扩容大小交给N                    
                        n = (tab = resize()).length;
                    //判断获取当前数组位置是否存在数据，如果为空则直接插入，
                    //否则需要代表当前位置不是空的，不是空的需要判断                        
                    if ((p = tab[i = (n - 1) & hash]) == null)
                        //如果为空则创建一个新的节点添加到该位置                    
                        tab[i] = newNode(hash, key, value, null);                
                    else {
                        Node<K,V> e; K k;
                        //判断Hash值和Key值是否相同，如果相同则需要Value覆盖
                        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))        
                            e = p;
                        //判断当前数组中存放的节点是否是树节点
                        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) {
                                    //添加完毕后判断当前链表节点有多少个，如果节点大于等于8则转换为红黑树
                                    p.next = newNode(hash, key, value, null);
                                    //treeifyBin判断当前数组是否为空，或者长度是否小于64，如果为空或者小于64
                                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                        //则先扩容
                                        treeifyBin(tab, hash);                                                
                                                                                                        
                                    break;
                                }
                                //再次进行Key的重复判断
                                if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))                    
                                    break;
                                p = e;
                            }
                        }
                        if (e != null) { // existing mapping for key
                            V oldValue = e.value;
                            if (!onlyIfAbsent || oldValue == null)
                                e.value = value;
                            afterNodeAccess(e);
                            return oldValue;
                        }
                    }
                    ++modCount;
                    //判断当前数组元素个数和阀值进行比较，如果数量大于阀值则需要扩容
                    if (++size > threshold)    
                        //默认情况下，第一次添加数据的时候，先会进行一次扩容后再添加数据
                        resize();
                    //后续都是先添加数据再扩容                        
                    afterNodeInsertion(evict);                                                                
                    return null;
                }

扩容： 默认情况下，数组大小为16，当数组元素 超过大小*负载因子（0.75），如果超过12个元素，则调用resize进行扩容，扩容原来大小的2倍
并且重新计算数组中元素的位置，所以比较耗费性能，一般创建集合尽量预知大小，避免多次扩容

3.2get流程

final Node<K,V> getNode(int hash, Object key) {
                Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
                if ((tab = table) != null && (n = tab.length) > 0 &&
                    (first = tab[(n - 1) & hash]) != null) {                                //判断数组以及数组对应位置数组元素是否为空
                    if (first.hash == hash && // always check first node
                        ((k = first.key) == key || (key != null && key.equals(k))))            //用get传递过来的Key值和对应位置第一个元素进行比较，如果相等直接返回，如果不等则进行查找
                        return first;
                    if ((e = first.next) != null) {                                            //判断第一个元素的下一个元素是否为空，如果不为空
                        if (first instanceof TreeNode)                                        //如果不为空判断当前节点是否为树节点
                            return ((TreeNode<K,V>)first).getTreeNode(hash, key);            //如果是树节点，直接通过getTreeNode拿到该节点返回
                        do {
                            if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))        //循环一一对比
                                return e;
                        } while ((e = e.next) != null);
                    }
                }
                return null;
            }

九.ConcurrentHashMap底层实现

1.ConcurrentHashMap和HashTable之间
ConcurrentHashMap性能高于HashTable，都能够完成线程安全操作，
Hashtable中线程安全使用synchronized同步方法进行加锁操作，如果当前一个线程正在访问该集合，其他线程是无法进行访问的，需要进行等待
反之ConcurrentHashMap当中采用分段锁机制

2. JDK1.7和JDK1.8底层实现的区别

2.1实现线程安全的方式

JDK1.7:ConcurrentHashMap（分段锁） 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。

JDK1.8:使用的是优化的synchronized 关键字 和 cas操作了维护并发。

2.2底层数据结构

JDK1.7:使用 Segment数组 + HashEntry数组 + 链表
JDK1.8:使用 Node数组+链表+ 红黑树

2.3 效率

JDK1.7:ConcurrentHashMap 使用的分段锁，如果一个线程占用一段，别的线程可以操作别的部分，
JDK1.8:简化结构，put和get不用二次哈希，一把锁只锁住一个链表或者一棵树，并发效率更加提升。

3. ConcurrentHashMap底层put方法实现的核心逻辑

public V put(K key, V value) {
                return putVal(key, value, false);
            }
            
            
            
            /** Implementation for put and putIfAbsent */
            final V putVal(K key, V value, boolean onlyIfAbsent) {
                if (key == null || value == null) throw new NullPointerException();                //判断key和value是否为空，如果为空则报异常
                int hash = spread(key.hashCode());                                                //重新计算key的hash值，有效减少Hash值冲突
                int binCount = 0;
                for (Node<K,V>[] tab = table;;) {                                                //遍历当前数组当中所有的数据
                    Node<K,V> f; int n, i, fh;
                    if (tab == null || (n = tab.length) == 0)                                    //判断数组是否为空
                        tab = initTable();                                                        //如果为空要进行数组的初始化操作
                    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {                    //根据key的Hash值找到位置，如果该位置没有元素
                        if (casTabAt(tab, i, null,
                                     new Node<K,V>(hash, key, value, null)))                    //获取到空的元素，然后重新创建一个新的Node放进去
                            break;                   // no lock when adding to empty bin
                    }
                    else if ((fh = f.hash) == MOVED)                                            //判断当前数组元素状态是否需要扩容
                        tab = helpTransfer(tab, f);
                    else {
                        V oldVal = null;
                        synchronized (f) {                                                        //加锁
                            if (tabAt(tab, i) == f) {                                
                                if (fh >= 0) {
                                    binCount = 1;
                                    for (Node<K,V> e = f;; ++binCount) {
                                        K ek;
                                        if (e.hash == hash &&                                    //判断添加的key和原有key进行Hash值判断以及key值判断，如果相等则覆盖
                                            ((ek = e.key) == key ||
                                             (ek != null && key.equals(ek)))) {
                                            oldVal = e.val;
                                            if (!onlyIfAbsent)
                                                e.val = value;
                                            break;
                                        }
                                        Node<K,V> pred = e;
                                        if ((e = e.next) == null) {                                //判断当前节点的下一个节点是否为空，如果为空则添加到下一个节点当中
                                            pred.next = new Node<K,V>(hash, key,
                                                                      value, null);
                                            break;
                                        }
                                    }
                                }
                                else if (f instanceof TreeBin) {                                //判断当前节点是否为红黑树
                                    Node<K,V> p;
                                    binCount = 2;
                                    if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                                   value)) != null) {            //如果为红黑树则创建一个树节点
                                        oldVal = p.val;
                                        if (!onlyIfAbsent)
                                            p.val = value;
                                    }
                                }
                            }
                        }
                        if (binCount != 0) {
                            if (binCount >= TREEIFY_THRESHOLD)                                    //根据当前循环次数判断链表中存在多少个数据，如果数据阀值大于等于8
                                                                                                //则进行红黑树转换
                                treeifyBin(tab, i);
                            if (oldVal != null)
                                return oldVal;
                            break;
                        }
                    }
                }
                addCount(1L, binCount);                                                            //判断是否需要扩容
                return null;
            }