问遍了身边的面试官朋友,我整理出这份 Java 集合高频面试题(2021年最新版)

微信搜索【程序员囧辉】,关注这个坚持分享技术干货的程序员。

我的最新文章:全网最硬核 Redis 大厂面试题解析(2021年最新版)

前言

大家好,我是囧辉,面试系列开篇:Java 基础高频面试题(2021年最新版),发表后受到不少同学的喜欢。

今天我们继续下一个重要的面试内容:集合框架。HashMap 作为 Java 中最靓的仔,毋庸置疑将是本文的主角。

 

可能有些同学看过我之前的 HashMap 文章:面试阿里,HashMap 这一篇就够了,会想:辉哥果然又颓废了、堕落了,估计是将之前的内容就照搬过来水一篇,鄙视,取关,不看也罢,*()&*……&*。

你们不对劲,你辉哥是这种人?当然不是的,本文的 HashMap 部分在之前的基础上进行了补充和完善,希望大家能看到完善的点。

最后,本文按 BAT 面试标准给出解析,希望在这金三银四的日子里,祝你一臂之力,拿下大厂 Offer。

 

面试系列

我自己前前后后加起来总共应该参加了不下四五十次的面试,拿到过几乎所有一线大厂的 offer:阿里、字节、美团、快手、拼多多等等。

每次面试后我都会将面试的题目进行记录,并整理成自己的题库,最近我将这些题目整理出来,并按大厂的标准给出自己的解析,希望在这金三银四的季节里,能助你一臂之力。

面试文章持续更新中... 

内容链接地址
面试经验分享921天,从小厂到入职阿里
两年Java开发工作经验面试总结
4 年 Java 经验,阿里网易拼多多面试总结、心得体会
5 年 Java 经验,字节、美团、快手核心部门面试总结(真题解析)
复习2个月拿下美团offer,我都做了些啥 
如何准备好一场大厂面试 
简历如何写一份让 HR 眼前一亮的简历(附模板)
Offer 选择跳槽,如何选择一家公司
Java 基础Java 基础高频面试题(2021年最新版)
一道有意思的“初始化”面试题
集合(HashMap)Java 集合框架高频面试题(2021年最新版)
面试阿里,HashMap 这一篇就够了
并发编程面试必问的线程池,你懂了吗?
面试必问的CAS,你懂了吗?
MySQL面试必问的 MySQL,你懂了吗?
MySQL 8.0 MVCC 核心原理解析(核心源码)
Spring面试必问的 Spring,你懂了吗?
Mybatis面试题:mybatis 中的 DAO 接口和 XML 文件里的 SQL 是如何建立关系的?
Redis面试必问的缓存使用:如何保证数据一致性、缓存设计模式
面试必问的 Redis:Memcached VS Redis
面试必问的 Redis:高可用解决方案哨兵、集群
面试必问的 Redis:主从复制
面试必问的 Redis:RDB、AOF、混合持久化
面试必问的 Redis:数据结构和基础概念
JVMJava虚拟机面试题精选(二)
Java虚拟机面试题精选(一)
分布式面试必问的分布式锁,你懂了吗?
算法位图法:判断一个数是否在40亿个整数中?
  

 

正文

1、介绍下 HashMap 的底层数据结构吧。

在 JDK 1.8,HashMap 底层是由 “数组+链表+红黑树” 组成,如下图所示,而在 JDK 1.8 之前是由 “数组+链表” 组成,就是下图去掉红黑树。

 

2、为什么使用“数组+链表”?

使用 “数组+链表” 是为了解决 hash 冲突的问题。

数组和链表有如下特点:

数组:查找容易,通过 index 快速定位;插入和删除困难,需要移动插入和删除位置之后的节点;

链表:查找困难,需要从头结点或尾节点开始遍历,直到寻找到目标节点;插入和删除容易,只需修改目标节点前后节点的 next 或 prev 属性即可;

HashMap 巧妙的将数组和链表结合在一起,发挥两者各自的优势,使用一种叫做 “拉链法” 的方式来解决哈希冲突。

首先通过 index 快速定位到索引位置,这边利用了数组的优点;然后遍历链表找到节点,进行节点的新增/修改/删除操作,这边利用了链表的优点。简直,完美。

 

3、为什么要改成“数组+链表+红黑树”?

通过上题可以看出,“数组+链表” 已经充分发挥了这两种数据结构的优点,是个很不错的组合了。

但是这种组合仍然存在问题,就是在定位到索引位置后,需要先遍历链表找到节点,这个地方如果链表很长的话,也就是 hash 冲突很严重的时候,会有查找性能问题,因此在 JDK1.8中,通过引入红黑树,来优化这个问题。

使用链表的查找性能是 O(n),而使用红黑树是 O(logn)。

 

4、那在什么时候用链表?什么时候用红黑树?

对于插入,默认情况下是使用链表节点。当同一个索引位置的节点在新增后超过8个(阈值8):如果此时数组长度大于等于 64,则会触发链表节点转红黑树节点(treeifyBin);而如果数组长度小于64,则不会触发链表转红黑树,而是会进行扩容,因为此时的数据量还比较小。

对于移除,当同一个索引位置的节点在移除后达到 6 个(阈值6),并且该索引位置的节点为红黑树节点,会触发红黑树节点转链表节点(untreeify)。

 

5、为什么链表转红黑树的阈值是8?

我们平时在进行方案设计时,必须考虑的两个很重要的因素是:时间和空间。对于 HashMap 也是同样的道理,简单来说,阈值为8是在时间和空间上权衡的结果(这 B 我装定了)。

红黑树节点大小约为链表节点的2倍,在节点太少时,红黑树的查找性能优势并不明显,付出2倍空间的代价作者觉得不值得。

理想情况下,使用随机的哈希码,节点分布在 hash 桶中的频率遵循泊松分布,按照泊松分布的公式计算,链表中节点个数为8时的概率为 0.00000006(就我们这QPS不到10的系统,根本不可能遇到嘛),这个概率足够低了,并且到8个节点时,红黑树的性能优势也会开始展现出来,因此8是一个较合理的数字。

 

6、那为什么转回链表节点是用的6而不是复用8?

如果我们设置节点多于8个转红黑树,少于8个就马上转链表,当节点个数在8徘徊时,就会频繁进行红黑树和链表的转换,造成性能的损耗。

 

7、HashMap 有哪些重要属性?分别用于做什么的?

除了用来存储我们的节点 table 数组外,HashMap 还有以下几个重要属性:

1)size:HashMap 已经存储的节点个数;

2)threshold:1)扩容阈值(主要),当 HashMap 的个数达到该值,触发扩容。2)初始化时的容量,在我们新建 HashMap 对象时, threshold 还会被用来存初始化时的容量。HashMap 直到我们第一次插入节点时,才会对 table 进行初始化,避免不必要的空间浪费。

3)loadFactor:负载因子,扩容阈值 = 容量 * 负载因子。

 

8、HashMap 的默认初始容量是多少?HashMap 的容量有什么限制吗?

默认初始容量是16。HashMap 的容量必须是2的N次方,HashMap 会根据我们传入的容量计算一个“大于等于该容量的最小的 2 的 N 次方”,例如传 16,容量为16;传17,容量为32。

 

9、“大于等于该容量的最小的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;
}

我们先不看第一行“int n = cap - 1”,先看下面的5行计算。

|=(或等于):这个符号比较少见,但是“+=”应该都见过,看到这你应该明白了。例如:a |= b ,可以转成:a = a | b。

>>>(无符号右移):例如 a >>> b 指的是将 a 向右移动 b 指定的位数,右移后左边空出的位用零来填充,移出右边的位被丢弃。

假设 n 的值为 0010 0001,则该计算如下图:

相信你应该看出来,这5个公式会通过最高位的1,拿到2个1、4个1、8个1、16个1、32个1。当然,有多少个1,取决于我们的入参有多大,但我们肯定的是经过这5个计算,得到的值是一个低位全是1的值,最后返回的时候 +1,则会得到1个比n 大的 2 的N次方。

这时再看开头的 cap - 1 就很简单了,这是为了处理 cap 本身就是 2 的N次方的情况。

计算机底层是二进制的,移位和或运算是非常快的,所以这个方法的效率很高。

PS:这是 HashMap 中我个人最喜欢的设计,非常巧妙。

 

10、HashMap 的容量必须是 2 的 N 次方,这是为什么?

核心目的是:实现节点均匀分布,减少 hash 冲突。

计算索引位置的公式为:(n - 1) & hash,当 n 为 2 的 N 次方时,n - 1 为低位全是 1 的值,此时任何值跟 n - 1 进行 & 运算的结果为该值的低 N 位,达到了和取模同样的效果,实现了均匀分布。实际上,这个设计就是基于公式:x mod 2^n = x & (2^n - 1),因为 & 运算比 mod 具有更高的效率。

如下图,当 n 不为 2 的 N 次方时,hash 冲突的概率明显增大。

 

11、HashMap 的插入流程是怎么样的?

真香,建议收藏。

 

12、插入流程的图里刚开始有个计算 key 的 hash 值,是怎么设计的?

源码如下:拿到 key 的 hashCode,并将 hashCode 的高16位和 hashCode 进行异或(XOR)运算,得到最终的 hash 值。

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

 

13、为什么要将 hashCode 的高16位参与运算?

主要是为了在 table 的长度较小的时候,让高位也参与运算,并且不会有太大的开销。

例如下图,如果高位不参与运算,由于 n - 1 是 0000 0111,所以结果只取决于 hash 值的低3位,无论高位怎么变化,结果都是一样的。

 

如果我们将高位参与运算,则索引计算结果就不会仅取决于低位。

 

14、扩容(resize)流程介绍下?

真香,建议收藏。

 

15、红黑树和链表都是通过 e.hash & oldCap == 0 来定位在新表的索引位置,这是为什么?

请看对下面的例子。

扩容前 table 的容量为16,a 节点和 b 节点在扩容前处于同一索引位置。

 

扩容后,table 长度为32,新表的 n - 1 只比老表的 n - 1 在高位多了一个1(图中标红)。

因为 2 个节点在老表是同一个索引位置,因此计算新表的索引位置时,只取决于新表在高位多出来的这一位(图中标红),而这一位的值刚好等于 oldCap。

因为只取决于这一位,所以只会存在两种情况:1)  (e.hash & oldCap) == 0 ,则新表索引位置为“原索引位置” ;2)(e.hash & oldCap) != 0,则新表索引位置为“原索引 + oldCap 位置”。

 

16、HashMap 是线程安全的吗?

不是。HashMap 在并发下存在数据覆盖、遍历的同时进行修改会抛出 ConcurrentModificationException 异常等问题,JDK 1.8 之前还存在死循环问题。

 

17、介绍一下死循环问题?

导致死循环的根本原因是 JDK 1.7 扩容采用的是“头插法”,会导致同一索引位置的节点在扩容后顺序反掉,在并发插入触发扩容时形成环,从而产生死循环。

而 JDK 1.8 之后采用的是“尾插法”,扩容后节点顺序不会反掉,不存在死循环问题。

 

JDK 1.7.0 的扩容代码如下,用例子来看会好理解点。

void transfer(Entry[] newTable) {
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            do {
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}

PS:这个流程较难理解,建议对着代码自己模拟走一遍。

例子:我们有1个容量为2的 HashMap,loadFactor=0.75,此时线程1和线程2 同时往该 HashMap 插入一个数据,都触发了扩容流程,接着有以下流程。

1)在2个线程都插入节点,触发扩容流程之前,此时的结构如下图。

2)线程1进行扩容,执行到代码:Entry<K,V> next = e.next 后被调度挂起,此时的结构如下图。

3)线程1被挂起后,线程2进入扩容流程,并走完整个扩容流程,此时的结构如下图。

由于两个线程操作的是同一个 table,所以该图又可以画成如下图。

4)线程1恢复后,继续走完第一次的循环流程,此时的结构如下图。

5)线程1继续走完第二次循环,此时的结构如下图。

6)线程1继续执行第三次循环,执行到 e.next = newTable[i] 时形成环,执行完第三次循环的结构如下图。

如果此时线程1调用 map.get(11) ,悲剧就出现了——无限循环。

 

18、总结下 JDK 1.8 主要进行了哪些优化?

JDK 1.8 的主要优化刚才我们都聊过了,主要有以下几点:

1)底层数据结构从“数组+链表”改成“数组+链表+红黑树”,主要是优化了 hash 冲突较严重时,链表过长的查找性能:O(n) -> O(logn)。

2)计算 table 初始容量的方式发生了改变,老的方式是从1开始不断向左进行移位运算,直到找到大于等于入参容量的值;新的方式则是通过“5个移位+或等于运算”来计算。

// JDK 1.7.0
public HashMap(int initialCapacity, float loadFactor) {
    // 省略
    // Find a power of 2 >= initialCapacity
    int capacity = 1;
    while (capacity < initialCapacity)
        capacity <<= 1;
    // ... 省略
}
// JDK 1.8.0_191
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;
}

3)优化了 hash 值的计算方式,老的通过一顿瞎JB操作,新的只是简单的让高16位参与了运算。

4)扩容时插入方式从“头插法”改成“尾插法”,避免了并发下的死循环。

5)扩容时计算节点在新表的索引位置方式从“h & (length-1)”改成“hash & oldCap”,性能可能提升不大,但设计更巧妙、更优雅。

 

19、Hashtable 是怎么加锁的 ?

Hashtable 通过 synchronized 修饰方法来加锁,从而实现线程安全。

public synchronized V get(Object key) {
    // ...
}

public synchronized V put(K key, V value) {
    // ...
}

 

20、LinkedHashMap 和 TreeMap 排序的区别?

LinkedHashMap 和 TreeMap 都是提供了排序支持的 Map,区别在于支持的排序方式不同:

LinkedHashMap:保存了数据的插入顺序,也可以通过参数设置,保存数据的访问顺序。

TreeMap:底层是红黑树实现。可以指定比较器(Comparator 比较器),通过重写 compare 方法来自定义排序;如果没有指定比较器,TreeMap 默认是按 Key 的升序排序(如果 key 没有实现 Comparable接口,则会抛异常)。

 

21、HashMap 和 Hashtable 的区别?

HashMap 允许 key 和 value 为 null,Hashtable 不允许。

HashMap 的默认初始容量为 16,Hashtable 为 11。

HashMap 的扩容为原来的 2 倍,Hashtable 的扩容为原来的 2 倍加 1。

HashMap 是非线程安全的,Hashtable 是线程安全的,使用 synchronized 修饰方法实现线程安全。

HashMap 的 hash 值重新计算过,Hashtable 直接使用 hashCode。

HashMap 去掉了 Hashtable 中的 contains 方法。

HashMap 继承自 AbstractMap 类,Hashtable 继承自 Dictionary 类。

HashMap 的性能比 Hashtable 高,因为 Hashtable 使用 synchronized 实现线程安全,还有就是 HashMap 1.8 之后底层数据结构优化成 “数组+链表+红黑树”,在极端情况下也能提升性能。

 

22、介绍下 ConcurrenHashMap,要讲出 1.7 和 1.8 的区别?

ConcurrentHashMap 是 HashMap 的线程安全版本,和 HashMap 一样,在JDK 1.8 中进行了较大的优化。

JDK1.7:底层结构为:分段的数组+链表;实现线程安全的方式:分段锁(Segment,继承了ReentrantLock),如下图所示。

 

 

JDK1.8:底层结构为:数组+链表+红黑树;实现线程安全的方式:CAS + Synchronized

 

区别:

1、JDK1.8 中降低锁的粒度。JDK1.7 版本锁的粒度是基于 Segment 的,包含多个节点(HashEntry),而 JDK1.8 锁的粒度就是单节点(Node)。

2、JDK1.8 版本的数据结构变得更加简单,使得操作也更加清晰流畅,因为已经使用 synchronized 来进行同步,所以不需要分段锁的概念,也就不需要 Segment 这种数据结构了,当前还保留仅为了兼容。

3、JDK1.8 使用红黑树来优化链表,跟 HashMap 一样,优化了极端情况下,链表过长带来的性能问题。

4、JDK1.8 使用内置锁 synchronized 来代替重入锁 ReentrantLock,synchronized 是官方一直在不断优化的,现在性能已经比较可观,也是官方推荐使用的加锁方式。

 

23、ConcurrentHashMap 的并发扩容

ConcurrentHashMap 在扩容时会计算出一个步长(stride),最小值是16,然后给当前扩容线程分配“一个步长”的节点数,例如16个,让该线程去对这16个节点进行扩容操作(将节点从老表移动到新表)。

如果在扩容结束前又来一个线程,则也会给该线程分配一个步长的节点数让该线程去扩容。依次类推,以达到多线程并发扩容的效果。

例如:64要扩容到128,步长为16,则第一个线程会负责第113(索引112)~128(索引127)的节点,第二个线程会负责第97(索引96)~112(索引111)的节点,依次类推。

具体处理(该流程后续可能会替换成流程图):

1)如果索引位置上为null,则直接使用 CAS 将索引位置赋值为 ForwardingNode(hash值为-1),表示已经处理过,这个也是触发并发扩容的关键点。

2)如果索引位置的节点 f 的 hash 值为 MOVED(-1),则代表节点 f 是 ForwardingNode 节点,只有 ForwardingNode 的 hash 值为 -1,意味着该节点已经处理过了,则跳过该节点继续往下处理。

3).否则,对索引位置的节点 f 对象使用 synchronized 进行加锁,遍历链表或红黑树,如果找到 key 和入参相同的,则替换掉 value 值;如果没找到,则新增一个节点。如果是链表,同时判断是否需要转红黑树。处理完在索引位置的节点后,会将该索引位置赋值为 ForwardingNode,表示该位置已经处理过。

 

ForwardingNode:一个特殊的 Node 节点,hash 值为-1(源码中定义成 MOVED),其中存储 nextTable 的引用。 只有发生扩容的时候,ForwardingNode才会发挥作用,作为一个占位符放在 table 中表示当前节点已经被处理(或则为 null )。

 

24、ConcurrenHashMap 和 Hashtable 的区别?

1)底层数据结构: 

ConcurrentHashMap:1)JDK1.7 采用 分段的数组+链表 实现;2)JDK1.8 采用 数组+链表+红黑树,跟 JDK1.8 的 HashMap 的底层数据结构一样。

Hashtable: 采用 数组+链表 的形式,跟 JDK1.8 之前的 HashMap 的底层数据结构类似。

 

2)实现线程安全的方式(重要):

ConcurrentHashMap:

1)JDK1.7:使用分段锁(Segment)保证线程安全,每个分段(Segment)包含若干个 HashEntry,当并发访问不同分段的数据时,不会产生锁竞争,从而提升并发性能。

2)JDK1.8:使用 synchronized + CAS 的方式保证线程安全,每次只锁一个节点(Node),进一步降低锁粒度,降低锁冲突的概率,从而提升并发性能。

Hashtable:使用 synchronized 修饰方法来保证线程安全,每个实例对象只有一把锁,并发性能较低,相当于串行访问。

 

25、ConcurrentHashMap 的 size() 方法怎么实现的?

JDK 1.7:先尝试在不加锁的情况下尝进行统计 size,最多统计3次,如果连续两次统计之间没有任何对 segment 的修改操作,则返回统计结果。否则,对每个segment 进行加锁,然后统计出结果,返回结果。

JDK 1.8:直接统计 baseCount 和 counterCells 的 value 值,返回的是一个近似值,如果有并发的插入或删除,实际的数量可能会有所不同。

该统计方式改编自 LongAdder 和 Striped64,这两个类在 JDK 1.8 中被引入,出自并发大神 Doug Lea 之手,是原子类(AtomicLong 等)的优化版本,主要优化了在并发竞争下,AtomicLong 由于 CAS 失败的带来的性能损耗。

值得注意的是,JDK1.8中,提供了另一个统计的方法 mappingCount,实现和 size 一样,只是返回的类型改成了 long,这也是官方推荐的方式。

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}
// 一个ConcurrentHashMap包含的映射数量可能超过int上限,
// 所以应该使用这个方法来代替size()
public long mappingCount() {
    long n = sumCount();
    return (n < 0L) ? 0L : n; // ignore transient negative values
}
final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

 

26、比较下常见的几种 Map,在使用时怎么选择?

 

30、ArrayList 和 Vector 的区别。

Vector 和 ArrayList 的实现几乎是一样的,区别在于:

1)最重要的的区别: Vector 在方法上使用了 synchronized 来保证线程安全,同时由于这个原因,在性能上 ArrayList 会有更好的表现。

2) Vector 扩容后容量默认变为原来 2 倍,而 ArrayList 为原来的 1.5 倍。

有类似关系的还有:StringBuilder 和 StringBuffer、HashMap 和 Hashtable。

 

31、ArrayList 和 LinkedList 的区别?

1、ArrayList 底层基于动态数组实现,LinkedList 底层基于双向链表实现。

2、对于随机访问(按 index 访问,get/set方法):ArrayList 通过 index 直接定位到数组对应位置的节点,而 LinkedList需要从头结点或尾节点开始遍历,直到寻找到目标节点,因此在效率上 ArrayList 优于 LinkedList。

3、对于随机插入和删除:ArrayList 需要移动目标节点后面的节点(使用System.arraycopy 方法移动节点),而 LinkedList 只需修改目标节点前后节点的 next 或 prev 属性即可,因此在效率上 LinkedList 优于 ArrayList。

4、对于顺序插入和删除:由于 ArrayList 不需要移动节点,因此在效率上比 LinkedList 更好。这也是为什么在实际使用中 ArrayList 更多,因为大部分情况下我们的使用都是顺序插入。

5、两者都不是线程安全的。

6、内存空间占用: ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间,而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间(因为要存放直接后继和直接前驱以及数据)。

 

32、HashSet 是如何保证不重复的?

HashSet 底层使用 HashMap 来实现,见下面的源码,元素放在 HashMap 的 key 里,value 为固定的 Object 对象。当 add 时调用 HashMap 的 put 方法,如果元素不存在,则返回 null 表示 add 成功,否则 add 失败。

由于 HashMap 的 Key 值本身就不允许重复,HashSet 正好利用 HashMap 中 key 不重复的特性来校验重复元素,简直太妙了。

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

 

33、TreeSet 清楚吗?能详细说下吗?

“TreeSet 和 TreeMap 的关系” 和上面说的 “HashSet 和 HashMap 的关系” 几乎一致。

TreeSet 底层默认使用 TreeMap 来实现。而 TreeMap 通过实现 Comparator(或 Key 实现 Comparable)来实现自定义顺序。

private transient NavigableMap<E,Object> m;
private static final Object PRESENT = new Object();

TreeSet(NavigableMap<E,Object> m) {
    this.m = m;
}
public TreeSet() {
    this(new TreeMap<E,Object>());
}

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

 

34、介绍下 CopyOnWriteArrayList?

CopyOnWriteArrayList 是 ArrayList 的线程安全版本,也是大名鼎鼎的 copy-on-write(COW,写时复制)的一种实现。

在读操作时不加锁,跟ArrayList类似;在写操作时,复制出一个新的数组,在新数组上进行操作,操作完了,将底层数组指针指向新数组。适合使用在读多写少的场景。

例如 add(E e) 方法的操作流程如下:使用 ReentrantLock 加锁,拿到原数组的length,使用 Arrays.copyOf 方法从原数组复制一个新的数组(length+1),将要添加的元素放到新数组的下标length位置,最后将底层数组指针指向新数组。

 

35、Comparable 和 Comparator 比较?

1、Comparable 是排序接口,一个类实现了 Comparable接口,意味着“该类支持排序”。Comparator 是比较器,我们可以实现该接口,自定义比较算法,创建一个 “该类的比较器” 来进行排序。

2、Comparable 相当于“内部比较器”,而 Comparator 相当于“外部比较器”。

3、Comparable 的耦合性更强,Comparator 的灵活性和扩展性更优。

4、Comparable 可以用作类的默认排序方法,而 Comparator 则用于默认排序不满足时,提供自定义排序。

 

耦合性和扩展性的问题,举个简单的例子:

当实现类实现了 Comparable 接口,但是已有的 compareTo 方法的比较算法不满足当前需求,此时如果想对两个类进行比较,有两种办法:

1)修改实现类的源代码,修改 compareTo 方法,但是这明显不是一个好方案,因为这个实现类的默认比较算法可能已经在其他地方使用了,此时如果修改可能会造成影响,所以一般不会这么做。

2)实现 Comparator 接口,自定义一个比较器,该方案会更优,自定义的比较器只用于当前逻辑,其他已有的逻辑不受影响。

 

36、List、Set、Map三者的区别?

List(对付顺序的好帮手): 存储的对象是可重复的、有序的。

Set(注重独一无二的性质):存储的对象是不可重复的、无序的。

Map(用 Key 来搜索的专业户): 存储键值对(key-value),不能包含重复的键(key),每个键只能映射到一个值。

 

37、Map、List、Set 分别说下你了解到它们有的线程安全类和线程不安全的类?

Map

线程安全:CocurrentHashMap、Hashtable

线程不安全:HashMap、LinkedHashMap、TreeMap、WeakHashMap

 

List

线程安全:Vector(线程安全版的ArrayList)、Stack(继承Vector,增加pop、push方法)、CopyOnWriteArrayList

线程不安全:ArrayList、LinkedList

 

Set

线程安全:CopyOnWriteArraySet(底层使用CopyOnWriteArrayList,通过在插入前判断是否存在实现 Set 不重复的效果)

线程不安全:HashSet(基于 HashMap)、LinkedHashSet(基于 LinkedHashMap)、TreeSet(基于 TreeMap)、EnumSet

 

38、Collection 与 Collections的区别

Collection:集合类的一个顶级接口,提供了对集合对象进行基本操作的通用接口方法。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式,常见的 List 与 Set 就是直接继承 Collection 接口。

Collections:集合类的一个工具类/帮助类,提供了一系列静态方法,用于对集合中元素进行排序、搜索以及线程安全等各种操作。

 

最后

面试系列持续创作中,有疑问的地方欢迎留言,我看到后都会回复。

原创不易,如果你觉得本文写的还不错,对你有帮助,请通过【点赞】和【关注】让我知道,支持我写出更好的文章。

我是囧辉,我的目标是帮助大家拿到心仪的大厂 Offer,我们下期见。

程序员囧辉 CSDN认证博客专家 Spring MySQL JVM
微信搜索【程序员囧辉】,领取本人原创大厂高频面试题 PDF、简历模板、进学习交流群。对技术有极致的追求,致力于写出小白也能看得懂的文章。
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 程序猿惹谁了 设计师:白松林 返回首页