一.了解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; }
