1、了解Map吗？用过哪些Map的实现
Map是公共接口，AbstractMap 是其抽象类，常用的 HashMap、ConsurrentHashMap、TreeMap 均继承了AbstractMap
- HashMap
- LinkedHashMap
- TreeMap
- ConcurrentHashMap
- SortedMap
- NavigableMap
2、说下 HashMap 和 Hashtable 的区别？
-
HashMap
- 底层是基于（数组+链表+红黑树）
- 不是线程安全的，在多线程并发的环境下，可能会产生死锁等问题
- 默认容量是16，之后每次扩充，容量变为原来的2倍
- 允许有空的健和值
-
HashTable
- 基于哈希表实现
- 线程安全的，它的每个方法中都加入了 synchronize 关键字修饰
- 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1
- 不允许有null的健和值
3、介绍下对象的 hashCode() 和 equals()，使用场景
- hashcode
顶级类Object里面的方法，所有的类都是继承Object,返回是一个int类型的数
根据一定的hash规则(存储地址，字段，长度等)，映射成一个数组，即散列值
- equals
顶级类Object里面的方法，所有的类都是继承Object,返回是一个boolean类型
根据自定义的匹配规则，用于匹配两个对象是否一样，一般逻辑如下
//判断地址是否一样
//非空判断和Class类型判断
//强转
//对象里面的字段一一匹配
使用场景：对象比较、或者集合容器里面排重、比较、排序
4、HashMap 和 TreeMap 应该怎么选择，使用场景？
-
HashMap: 散列桶(数组+链表+红黑树)，可以实现快速的存储和检索，存储的数据是无序的，适用于插入删除和定位元素较多的场景 -
TreeMap: 使用存储结构是一个平衡二叉树（红黑树），可以自定义排序规则，要实现Comparator接口
能便捷的实现内部元素的各种排序，但是一般性能比HashMap差，适用于按照自然排序或者自定义排序规则(写过微信支付签名工具类就用这个类)
5、Set 和 Map 的关系
Set 类的核心就是不保存重复的元素，存储一组唯一的对象
Set 的每一种实现都是对应 Map里面的一种封装，HashSet对应的就是HashMap，TreeSet对应的就是TreeMap
6、常见 Map 的排序规则是怎样的？
- 按照添加顺序使用 LinkedHashMap
- 自然排序使用 TreeMap
- 自定义排序 TreeMap(Comparetor c)
7、如果需要线程安全，且效率高的Map，应该怎么做？
-
使用 concurrent 包下的
ConcurrentHashMap -
使用
Collections.synchronizedMap()，ConcurrentHashMap 虽然是线程安全，但是他的效率比 HashTable 要高很多
8、为什么Collections.synchronizedMap后是线程安全的？
-
使用
Collections.synchronizedMap将HashMap作为构造函数参数传递进行了一层包装，对SynchronizedMap 的增删改查等操作都使用 synchronized 加锁 -
装饰者设计模式
9、看过 HashMap 源码吗？介绍下你了解的 HashMap
一旦面试官问你这个问题，一定要有自己清晰的回答思路，不能东一块西一块的，可以用以下几个方法回答对 HashMap 的立即
- 底层数据结构
- 初始化大小、时机，扩容机制是怎样的
- put 元素过程
HashMap底层(数组+链表+红黑树 jdk8才有红黑树)
数组中每一项是一个链表，即数组和链表的结合体
Node<K,V>[] table 是数组，数组的元素是Entry(Node继承Entry)，Entry元素是一个key-value的键值对，它持有一个指向下个Entry的引用，table数组的每个Entry元素同时也作为当前Entry链表的首节点，也指向了该链表的下个Entry元素
在JDK1.8中，链表的长度大于8，链表会转换成红黑树
10、什么是Hash碰撞？常见的解决办法有哪些？HashMap采用哪种方法？
- hash 碰撞的意思是不同 key 计算得到的 hash 值相同，需要放到同一个 bucket 桶中
- hash 碰撞常见的解决办法：链表法、开发地址法、再哈希法等
- HashMap 采用的是链表法，即多个 key 有相同的 hash 值时，就将这个 key 作为链表的节点
11、HashMap 底层数据结构为什么是数组+链表+红黑树？
- 数组 Node<K,V>[] table ，根据对象的key的hash值进行在数组里面是哪个节点
- 链表的作用是解决hash冲突，将hash值一样的对象存在一个链表放在hash值对应的槽位
- 红黑树 JDK8使用红黑树来替代超过8个节点的链表，主要是查询性能的提升，从原来的O(n)到O(logn),
通过hash碰撞，让HashMap不断产生碰撞，那么相同的key的位置的链表就会不断增长，当对这个Hashmap的相应位置进行查询的时候，就会循环遍历这个超级大的链表，性能就会下降，所以改用红黑树
12、为啥选择红黑树而不用其他树，比如二叉查找树，为啥不一直开始就用红黑树，而是到8的长度后才变换
二叉查找树在特殊情况下也会变成一条线性结构，和原先的链表存在一样的深度遍历问题，查找性能就会慢，
使用红黑树主要是提升查找数据的速度，红黑树是平衡二叉树的一种，插入新数据后会通过左旋，右旋、变色等操作来保持平衡，解决单链表查询深度的问题
数据量少的时候操作数据，遍历线性表比红黑树所消耗的资源少，且前期数据少 平衡二叉树保持平衡是需要消耗资源的，所以前期采用线性表，等到一定数之后变换到红黑树
13、说下 HashMap 的 put 和 get 的核心逻辑（JDK8以上版本）
put核心流程
public V put(K key, V value) {
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;
// table为空,调用 resize() 方法初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 计算 hash 值所在桶的位置，如果为空，执行 newNode() 方法
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 如果当前桶已经有值了
// 拉链法
Node<K,V> e; K k;
// 判断桶的首节点是否匹配
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 {
// 链表结构
// 遍历链表，索引从0开始
for (int binCount = 0; ; ++binCount) {
// p.next == null, 已经到达链表尾部，尾插法添加新 Node
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 链表的长度大于等于8，调用 treeifyBin() 方法
// 链表长度大于等于8只是转换为红黑树条件之一
// 就还需要 table 大小 >64
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// e不为空，表示map 中存在key的映射，则替换旧的 value 并直接返回
if (e != null) { // existing mapping for key
// 去除当前节点的值,赋值给 oldValue
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// put 过程中创建新的 Node，那么modCount 和 size 都加1
++modCount;
if (++size > threshold)
// 达到扩容阈值，执行 resize() 方法扩容
resize();
afterNodeInsertion(evict);
return null;
}
get核心流程
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) {
//获取首节点，hash碰撞概览小，通常链表第一个节点就是值，没必要去循环遍历，处于效率
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果不止一个节点，就需要循环遍历，存在多个hash碰撞
if ((e = first.next) != null) {
//判断是否是红黑树，如果是则调用树的查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//链表结构，则循环遍历获取节点
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
14、了解 ConcurrentHashMap 吗？为什么性能比HashTable高，说下原理
- ConcurrentHashMap 使用了
synchronized 关键字+CAS自旋锁保证线程安全性，并且采用了分段锁的思想将锁的粒度细化，在保证线程安全性前提下，提高性能 - HashTable 类基本上所有的方法都是采用synchronized关键字修饰，是一个全局锁，虽然实现了线程安全控制高，但并发情况下效率就降低
15、jdk1.7 和 jdk1.8 里面 ConcurrentHashMap 实现的区别有没了解？
JDK8之前，ConcurrentHashMap使用锁分段技术，将数据分成一段段存储，每个数据段配置一把锁，即segment类，这个类继承ReentrantLock来保证线程安全
技术点：Segment+HashEntry
JKD8的版本取消Segment这个分段锁数据结构，底层也是使用Node数组+链表+红黑树，从而实现对每一段数据就行加锁，也减少了并发冲突的概率，CAS(读)+Synchronized(写)
技术点：Node+Cas+Synchronized
16、说下 ConcurrentHashMap 的 put 方法的核心逻辑（JDK8以上版本）
spread(key.hashCode()) 重哈希，减少碰撞概率
tabAt(i) 获取table中索引为i的Node元素
casTabAt(i) 利用CAS操作获取table中索引为i的Node元素
put的核心流程
1、key进行重哈希spread(key.hashCode())
2、对当前table进行无条件循环
3、如果没有初始化table，则用initTable进行初始化
4、如果没有hash冲突，则直接用cas插入新节点，成功后则直接判断是否需要扩容，然后结束
5、(fh = f.hash) == MOVED 如果是这个状态则是扩容操作，先进行扩容
6、存在hash冲突，利用synchronized (f) 加锁保证线程安全
7、如果是链表，则直接遍历插入，如果数量大于8，则需要转换成红黑树
8、如果是红黑树则按照红黑树规则插入
9、最后是检查是否需要扩容addCount()
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
// hash 对hashcode再散列
int hash = spread(key.hashCode());
int binCount = 0;
// 遍历bucket数组，自旋
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 懒加载 延迟构建
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 拿到对应bucket的头节点为空
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 通过CAS插入头节点 失败就从头开始循环
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 如果正在扩容，当前线程帮助进行扩容
// 每个线程只能同时负责一个bucket上的数据迁移，但是并不影响其他桶的put和get操作
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// 存在hash碰撞，获取头节点的锁再进行操作
else {
V oldVal = null;
synchronized (f) {
// 再次检查头节点是否有变化，有变化进入下一轮自旋
if (tabAt(tab, i) == f) {
// 当前bucket是链表
if (fh >= 0) {
binCount = 1;
// 遍历链表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// key相同，覆盖
if (e.hash == hash &&
((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;
}
}
}
// 当前bucket是红黑树
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)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 判断是不是需要进行扩容操作
addCount(1L, binCount);
return null;
}
参考资料