2021大厂Java面试真题(Java 集合 )

1、说说 List, Set, Queue, Map 四者的区别?

  • List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
  • Set(注重独一无二的性质): 存储的元素是无序的、不可重复的。
  • Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序,存储的元素是有序

的、可重复的。

  • Map(用 key 来搜索的专家): 使用键值对(key-value)存储,类似于数学上的函数

y=f(x),“x” 代表 key,“y” 代表 value,key 是无序的、不可重复的,value 是无序的、

可重复的,每个键最多映射到一个值

2、如何选用集合?

主要根据集合的特点来选用,比如我们需要根据键值获取到元素值时就选用 Map 接口下

的集合,需要排序时选择 TreeMap,不需要排序时就选择 HashMap,需要保证线程安全就选

用 ConcurrentHashMap。

当我们只需要存放元素值时,就选择实现 Collection 接口的集合,需要保证元素唯一时

选择实现 Set 接口的集合比如 TreeSet 或 HashSet,不需要就选择实现 List 接口的比

如 ArrayList 或 LinkedList,然后再根据实现这些接口的集合的特点来选用。

3、为什么要使用集合?

当我们需要保存一组类型相同的数据的时候,我们应该是用一个容器来保存,这个容器就

是数组,但是,使用数组存储对象具有一定的弊端, 因为我们在实际开发中,存储的数据的

类型是多种多样的,于是,就出现了“集合”,集合同样也是用来存储多个数据的。

数组的缺点是一旦声明之后,长度就不可变了;同时,声明数组时的数据类型也决定了该

数组存储的数据的类型;而且,数组存储的数据是有序的、可重复的,特点单一。 但是集合

提高了数据存储的灵活性,Java 集合不仅可以用来存储不同类型不同数量的对象,还可以保

存具有映射关系的数据。

4、 Arraylist 和 Vector 的区别?

  • ArrayList 是 List 的主要实现类,底层使用 Object[]存储,适用于频繁的查找工作,线程

不安全 ;

  • Vector 是 List 的古老实现类,底层使用 Object[] 存储,线程安全的。

5、Arraylist 与 LinkedList 区别?

  • 是否保证线程安全: ArrayList 和 LinkedList 都是不同步的,也就是不保证线程安全;
  • 底层数据结构: Arraylist 底层使用的是 Object 数组;LinkedList 底层使用的是 双向链

表 数据结构(JDK1.6 之前为循环链表,JDK1.7 取消了循环。注意双向链表和双向循环

链表的区别,下面有介绍到!)

  • 插入和删除是否受元素位置的影响:

a. ArrayList 采用数组存储,所以插入和删除元素的时间复杂度受元素位置的影响。 比

如:执行 add(E e)方法的时候, ArrayList 会默认在将指定的元素追加到此列表的末

尾,这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话

(add(int index, E element))时间复杂度就为 O(n-i)。因为在进行上述操作的时候

集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。

b. LinkedList 采用链表存储,所以,如果是在头尾插入或者删除元素不受元素位置的影

响(add(E e)、addFirst(E e)、addLast(E e)、removeFirst() 、 removeLast()),

近似 O(1),如果是要在指定位置 i 插入和删除元素的话(add(int index, E element),

remove(Object o)) 时间复杂度近似为 O(n) ,因为需要先移动到指定位置再插入。

  • 是否支持快速随机访问: LinkedList 不支持高效的随机元素访问,而 ArrayList 支持。快

速随机访问就是通过元素的序号快速获取元素对象(对应于 get(int index)方法)。

  • 内存空间占用: ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空

间,而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空

间(因为要存放直接后继和直接前驱以及数据)。

6、Comparable 和 Comparator 的区别?

  • comparable 接口实际上是出自 java.lang 包 它有一个 compareTo(Object obj)方法用

来排序

  • comparator 接口实际上是出自 java.util 包它有一个 compare(Object obj1, Object

obj2)方法用来排序

一般我们需要对一个集合使用自定义排序时,我们就要重写 compareTo()方法或

compare()方法,当我们需要对某一个集合实现两种排序方式,比如一个 song 对象中的歌名

和歌手名分别采用一种排序方法的话,我们可以重写 compareTo()方法和使用自制的

Comparator 方法或者以两个 Comparator 来实现歌名排序和歌星名排序,第二种代表我们

只能使用两个参数版的 Collections.sort().

7、无序性和不可重复性的含义是什么

  • 什么是无序性?无序性不等于随机性 ,无序性是指存储的数据在底层数组中并非按照数组

索引的顺序添加 ,而是根据数据的哈希值决定的。

  • 什么是不可重复性?不可重复性是指添加的元素按照 equals()判断时 ,返回 false,需要

同时重写 equals()方法和 HashCode()方法。

8、比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同

  • HashSet 是 Set 接口的主要实现类 ,HashSet 的底层是 HashMap,线程不安全的,可

以存储 null 值;

  • LinkedHashSet 是 HashSet 的子类,能够按照添加的顺序遍历;
  • TreeSet 底层使用红黑树,元素是有序的,排序的方式有自然排序和定制排序。

9、试比较 Queue 与 Deque 的区别

Queue 是单端队列,只能从一端插入元素,另一端删除元素,实现上一般遵循 先进先出

(FIFO) 规则。

Queue 扩展了 Collection 的接口,根据 因为容量问题而导致操作失败后处理方式的不

同 可以分为两类方法: 一种在操作失败后会抛出异常,另一种则会返回特殊值。

javaSE集合面试题 java集合面试题及答案_开发语言

Deque 是双端队列,在队列的两端均可以插入或删除元素。

Deque 扩展了 Queue 的接口, 增加了在队首和队尾进行插入和删除的方法,同样根据失

败后处理方式的不同分为两类:

javaSE集合面试题 java集合面试题及答案_开发语言_02

10、请谈一下对 PriorityQueue 的认识?

PriorityQueue 是在 JDK1.5 中被引入的, 其与 Queue 的区别在于元素出队顺序是与优先

级相关的,即总是优先级最高的元素先出队。

这里列举其相关的一些要点:

  • PriorityQueue 利用了二叉堆的数据结构来实现的,底层使用可变长的数组来存储数据
  • PriorityQueue 通过堆元素的上浮和下沉,实现了在 O(logn) 的时间复杂度内插入元素和

删除堆顶元素。

  • PriorityQueue 是非线程安全的,且不支持存储 NULL 和 non-comparable 的对象。
  • PriorityQueue 默认是小顶堆,但可以接收一个 Comparator 作为构造参数,从而来自定

义元素优先级的先后。

11、HashMap 和 Hashtable 的区别?

  • 线程是否安全: HashMap 是非线程安全的,Hashtable 是线程安全的,因

为 Hashtable 内部的方法基本都经过 synchronized 修饰。(如果你要保证线程安全的

话就使用 ConcurrentHashMap 吧!);

  • 效率: 因为线程安全的问题,HashMap 要比 Hashtable 效率高一点。另外,

Hashtable 基本被淘汰,不要在代码中使用它;

  • 对 Null key 和 Null value 的支持: HashMap 可以存储 null 的 key 和 value,但 null

作为键只能有一个,null 作为值可以有多个;Hashtable 不允许有 null 键和 null 值,否

则会抛出 NullPointerException。

  • 初始容量大小和每次扩充容量大小的不同 : ① 创建时如果不指定容量初始值,

Hashtable 默认的初始大小为 11,之后每次扩充,容量变为原来的 2n+1。

HashMap 默认的初始化大小为 16。之后每次扩充,容量变为原来的 2 倍。② 创建时如

果给定了容量初始值,那么 Hashtable 会直接使用你给定的大小,而 HashMap 会将其

扩充为 2 的幂次方大小(HashMap 中的 tableSizeFor()方法保证,下面给出了源代

码)。也就是说 HashMap 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2

的幂次方。

  • 底层数据结构: JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化,当链表

长度大于阈值(默认为 8)(将链表转换成红黑树前会判断,如果当前数组的长度小于

64,那么会选择先进行数组扩容,而不是转换为红黑树)时,将链表转化为红黑树,以减

少搜索时间。Hashtable 没有这样的机制。

12、HashSet 如何检查重复?

当你把对象加入 HashSet 时,HashSet 会先计算对象的 hashcode 值来判断对象加入

的位置,同时也会与其他加入的对象的 hashcode 值作比较,如果没有相符的 hashcode,

HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象,这时会调用

equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同,HashSet 就不会

让加入操作成功。

在 openjdk8 中,HashSet 的 add()方法只是简单的调用了 HashMap 的 put()方法,

并且判断了一下返回值以确保是否有重复元素。 也就是说,在 openjdk8 中,实际上无论

HashSet 中是否已经存在了某元素,HashSet 都会直接插入,只是会在 add()方法的返回

值处告诉我们插入前是否存在相同元素。

13、HashMap 的长度为什么是 2 的幂次方?

为了能让 HashMap 存取高效,尽量较少碰撞,也就是要尽量把数据分配均匀。我们上面

也讲到了过了,Hash 值的范围值-2147483648 到 2147483647,前后加起来大概 40 亿

的映射空间,只要哈希函数映射得比较均匀松散,一般应用是很难出现碰撞的。但问题是一个

40 亿长度的数组,内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做

对数组的长度取模运算,得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组

下标的计算方法是“ (n - 1) & hash”。(n 代表数组长度)。这也就解释了 HashMap 的

长度为什么是 2 的幂次方。

这个算法应该如何设计呢?

我们首先可能会想到采用%取余的操作来实现。但是,重点来了:“取余(%)操作中如果

除数是 2 的幂次则等价于与其除数减一的与(&)操作(也就是说

hash%length==hash&(length-1)的前提是 length 是 2 的 n 次方;)。” 并且 采用二进制

位操作 &,相对于%能够提高运算效率,这就解释了 HashMap 的长度为什么是 2 的幂次方。

14、ConcurrentHashMap 和 Hashtable 的区别?

ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

  • 底层数据结构: JDK1.7 的 ConcurrentHashMap 底层采用 分段的数组+链表 实现,

JDK1.8 采用的数据结构跟 HashMap1.8 的结构一样,数组+链表/红黑二叉树。

Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形

式,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突而存在的;

  • 实现线程安全的方式(重要): ① 在 JDK1.7 的时候,ConcurrentHashMap(分段

锁) 对整个桶数组进行了分割分段(Segment),每一把锁只锁容器其中一部分数据,多线

程访问容器里不同数据段的数据,就不会存在锁竞争,提高并发访问率。 到了 JDK1.8

的时候已经摒弃了 Segment 的概念,而是直接用 Node 数组+链表+红黑树的数据结构

来实现,并发控制使用 synchronized 和 CAS 来操作。(JDK1.6 以后

对 synchronized 锁做了很多优化) 整个看起来就像是优化过且线程安全的 HashMap,

虽然在 JDK1.8 中还能看到 Segment 的数据结构,但是已经简化了属性,只是为了兼容

旧版本;② Hashtable(同一把锁) :使用 synchronized 来保证线程安全,效率非常低下。

当一个线程访问同步方法时,其他线程也访问同步方法,可能会进入阻塞或轮询状态,如

使用 put 添加元素,另一个线程不能使用 put 添加元素,也不能使用 get,竞争会越来越

激烈效率越低。

15、ConcurrentHashMap 线程安全的具体实现方式是怎样的?

JDK1.7

首先将数据分为一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其

中一个段数据时,其他段的数据也能被其他线程访问。

ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成。

Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁,扮演锁的角色。

HashEntry 用于存储键值对数据。

static class Segment<K,V> extends ReentrantLock implements Serializable {

}

一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构

和 HashMap 类似,是一种数组和链表结构,一个 Segment 包含一个 HashEntry 数组,每

个 HashEntry 是一个链表结构的元素,每个 Segment 守护着一个 HashEntry 数组里的元

素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment 的锁。

JDK1.8

ConcurrentHashMap 取消了 Segment 分段锁,采用 CAS 和 synchronized 来保证并

发安全。数据结构跟 HashMap1.8 的结构类似,数组+链表/红黑二叉树。Java 8 在链表长

度超过一定阈值(8)时将链表(寻址时间复杂度为 O(N))转换为红黑树(寻址时间复杂度

为 O(log(N)))

synchronized 只锁定当前链表或红黑二叉树的首节点,这样只要 hash 不冲突,就不会

产生并发,效率又提升 N 倍。

16、TreeMap 和 TreeSet 在排序时如何比较元素?Collections 工具类中的 sort()方法如何 比较元素?

TreeSet 要求存放的对象所属的类必须实现 Comparable 接口,该接口提供了比较元素

的 compareTo()方法,当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键

值对映射的键必须实现 Comparable 接口从而根据键对元素进行排序。

Collections 工具类的 sort 方法有两种重载的形式:

第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比

较。

第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是

Comparator 接口的子类型(需要重写 compare 方法实现元素的比较),相当于一个临时定

义的排序规则,其实就是通过接口注入比较元素大小的算法,也是对回调模式的应用(Java

中对函数式编程的支持)。

17、Collection 和 Collections 有什么区别?

java.util.Collection 是一个集合接口(集合类的一个顶级接口)。它提供了对集合对象进

行基本操作的通用接口方法。Collection 接口在 Java 类库中有很多具体的实现。Collection

接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有 List 与

Set。

Collections 则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合

中元素进行排序、搜索以及线程安全等各种操作。

18、Array 和 ArrayList 有何区别?

  • Array 可以存储基本数据类型和对象,ArrayList 只能存储对象。

 Array 是指定固定大小的,而 ArrayList 大小是自动扩展的。

  • Array 内置方法没有 ArrayList 多,比如 addAll、removeAll、iteration 等方法只有

ArrayList 有。

对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据

类型的时候,这种方式相对比较慢。

19、HashMap 和 ConcurrentHashMap 的区别

ConcurrentHashMap 对整个桶数组进行了分割分段(Segment),然后在每一个分段上

都用 lock 锁进行保护,相对于 HashTable 的 synchronized 锁的粒度更精细了一些,并

发性能更好,而 HashMap 没有锁机制,不是线程安全的。(JDK1.8 之后

ConcurrentHashMap 启用了一种全新的方式实现,利用 CAS 算法。)

HashMap 的键值对允许有 null,但是 ConCurrentHashMap 都不允许。

20、如果使用 Object 作为 HashMap 的 Key,应该怎么办呢?

重写 hashCode()和 equals()方法

  • 重写 hashCode()是因为需要计算存储数据的存储位置,需要注意不要试图从散列码计算

中排除掉一个对象的关键部分来提高性能,这样虽然能更快但可能会导致更多的 Hash

碰撞。

  • 重写 equals()方法,需要遵守自反性、对称性、传递性、一致性以及对于任何非 null 的

引用值 x,x.equals(null)必须返回 false 的这几个特性,目的是为了保证 key 在哈希表

中的唯一性。

21、为什么 HashMap 中 String、Integer 这样的包装类适合作为 K?

String、Integer 等包装类的特性能够保证 Hash 值的不可更改性和计算准确性,能够有

效的减少 Hash 碰撞的几率。

  • 都是 final 类型,即不可变性,保证 key 的不可更改性,不会存在获取 hash 值不同的

情况

  • 内部已重写了 equals()、hashCode()等方法,遵守了 HashMap 内部的规范(不清楚

可以去上面看看 putValue 的过程),不容易出现 Hash 值计算错误的情况;

22、什么是哈希冲突?

当两个不同的输入值,根据同一散列函数计算出相同的散列值的现象,我们就把它叫做碰

撞(哈希碰撞)。

23、你知道 fail-fast 和 fail-safe 吗?

fail-fast 是 Java 中的一种 快速失败 机制,java.u til 包下所有的集合都是快速失败的,

快速失败会抛出 ConcurrentModificationException 异常,fa ail-fast 你可以把它理解为一

种快速检测机制它只能用来检测错误,不会对错误进行恢复,fail-fast 不一定只在多线程 环

境下存在,ArrayList 也会抛出这个异常,主要原因是由于 modCount 不等于 ex

pectedModCount。

fail-safe 是 Java 中的一种安全失败机制,它表示的是在遍历时不是直接在原集合上进

行访问,而是先复制原有集合内容,在拷贝的集合上进行遍历。 由于迭代时是对原集合的拷

贝进行遍历,所以在 遍历过程中对原集合所作的修改并不能被迭代器检测到 所以不会触

发 ConcurrentModificationException。java.util.conc urrent 包下的容器都是安全失败的,

可以在多线程条件下使用,并发修改。

24、Arrays.asList 获得的 List 应该注意什么?

Arrays.asList 是 Array 中的一个静态方法,它能够实现把数组转换成为 List 序列,需要注

意下面几点:

  • Arrays.asList 转换完成后的 List 不能再进行结构化的的修改,什么是结构化的修改?就

是不能再进行任何 List 元素的增加或者减少的操作。

public static void main(String[] args) {
Integer[] integer = new Integer[] { 1, 2, 3, 4 };
List integetList = Arrays.asList(integer);
integetList.add(5);
}
// 结果抛出异常
// Exception in thread “main” java.lang.UnsupportedOperationException

我们看源码就很容易发现问题:

// 这是 java.util.Arrays 内部类,
//而不是 java.util.ArrayList
private static class ArrayList extends AbstractList
implements RandomAccess, java.io.Serializable

继承 AbstractList 中对 add、remove、set 方法是直接抛异常的,也就是说如果继承的

子类没有去重写这些方法,那么子类的实例去调用这些方法是会直接抛异常的。

25、final、finally 和 finalize()的区别

finally 是一个关键字,它经常和 try 块一起使用,用于异常处理。使用 try…finally 的代码块种,

finally 部分的代码一定会被执行,所以我们经常在 finallv 方法中用于资源的关闭操作。

JDK1.7 中,推荐使用 try-with-resources 优雅的关闭资源,它直接使用 try0 进行资源的关闭即可,

就不用写 finally 关键字了。

finalize 是 Object 对象中的一个方法,用于对象的回收方法,这个方法我们一般不推荐使用,

finalize 是和垃圾回收关联在一起的,在 Java9 中,将 finalize 标记为了 deprecated,如果没有

特别原因,不要实现 finalize 方法,也不要指望他来进行垃圾回收。

26、内部类有哪些分类,分别解释一下

在 Java 中,可以将一个类的定义放在另外一个类的定义内部,这就是内部类。内部类本身就是

类的一个属性,与其他属性定义方式一致。内部类的分类一般主要有四种:

  • 成员内部类
  • 局部内部类
  • 匿名内部类
  • 静态内部类

静态内部类就是定义在类内部的静态类,静态内部类可以访问外部类所有的静态变量,而不可访

问外部类的非静态变量;

成员内部类就是定义在类内部,成员位置上的非静态类,就是成员内部类。成员内部类可以访问

外部类所有的变量和方法,包括静态和非静态,私有和公有。

定义在方法中的内部类,就是局部内部类。定义在实例方法中的局部类可以访问外部类的所有变

量和方法,定义在静态方法中的局部类只能访问外部类的静态变量和方法。

匿名内部类就是没有名字的内部类,除了没有名字,匿名内部类还有以下特点:

  • 匿名内部类必须继承一个抽象类或者实现一个接口
  • 匿名内部类不能定义任何静态成员和静态方法。
  • 当所在的方法的形参需要被匿名内部类使用时,必须声明为 final.
  • 匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。

27、项目为 UTF-8 环境,charc=中,是否合法

可以,因为 Unicode 编码采用 2 个字节的编码,UTF-8 是 Unicode 的一种实现,它使用可

变长度的字符集进行编码,charc=中是两个字节,所以能够存储。合法。

28、动态代理是基于什么原理

代理一般分为静态代理和动态代理,它们都是代理模莫式的一种应用,静态代理指的是在程序运

行前已经编译好,程序知道由谁来执行代理方法。

而动态代理只有在程序运行期间才能确定,相比于静态代理,动态代理的优势在于可以很方便的

对代理类的函数进行统一的处理,而不用修改每个代理类中的方法。可以说动态代理是基于反射实现

的。通过反射我们可以直接操作类或者对象,比如获取类的定义,获取声明的属性和方法,调用方法,

在运行时可以修改类的定义。

动态代理是一种在运行时构建代理、动态处理方法调用的机制。动态代理的实现方式有很多,

Java 提供的代理被称为 JDK 动态代理,JDK 动态代理是基于类的继承。

29、Exception 和 Error 有什么区别

Exception 泛指的是异常,Exception 主要分为两种异常,一种是编译期出现的异常,称为

checkedException,一种是程序运行期间出现的异常常,称为 uncheckedException,常见的

checkedException 有 IOException,uncheckedExc eption 统称为 RuntimeException ,常见的

RuntimeException 主要有 NullPointerException、IllegalArgumentException 、

ArrayIndex0utofB oundException 等,Exception 可以被捕获。

Error 是指程序运行过程中出现的错误,通常情况下会造成程序的崩溃,Error 通常是不可恢复的,

Error 不能被捕获。

30、反射的基本原理,反射创建类实例的三和方式是什么

反射机制就是使 Java 程序在运行时具有自省(introsp ect) 的能力,通过反射我们可以直接操作

类 和对象,比如获取某个类的定义,获取类的属性和方法 构造方法等。

创建类实例的三种方式是

  • 对象实例.getClass();
  • 通过 ClassforName()创建

Exception 泛指的是异常,Exception 主要分为两种异常,一种是编译期出现的异常,称为

checkedException,一种是程序运行期间出现的异常常,称为 uncheckedException,常见的

checkedException 有 IOException,uncheckedExc eption 统称为 RuntimeException ,常见的

RuntimeException 主要有 NullPointerException、IllegalArgumentException 、

ArrayIndex0utofB oundException 等,Exception 可以被捕获。

Error 是指程序运行过程中出现的错误,通常情况下会造成程序的崩溃,Error 通常是不可恢复的,

Error 不能被捕获。

30、反射的基本原理,反射创建类实例的三和方式是什么

反射机制就是使 Java 程序在运行时具有自省(introsp ect) 的能力,通过反射我们可以直接操作

类 和对象,比如获取某个类的定义,获取类的属性和方法 构造方法等。

创建类实例的三种方式是

  • 对象实例.getClass();
  • 通过 ClassforName()创建
  • 对象实例.newInstance)方法创建