Java集合面试题（总结最全面的面试题）

我会带着你远行 2023-09-28 11:56 90阅读 0赞

### 集合容器概述 ###

#### 什么是集合 ####

*  集合就是一个放数据的容器，准确的说是放数据对象引用的容器
 *  集合类存放的都是对象的引用，而不是对象的本身
 *  集合类型主要有3种：set(集）、list(列表）和map(映射)。

#### 集合的特点 ####

*  集合的特点主要有如下两点：
    
     *  集合用于存储对象的容器，对象是用来封装数据，对象多了也需要存储集中式管理。
     *  和数组对比对象的大小不确定。因为集合是可变长度的。数组需要提前定义大小

#### 集合和数组的区别 ####

*  数组是固定长度的；集合可变长度的。
 *  数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
 *  数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

#### 使用集合框架的好处 ####

1.  容量自增长；
2.  提供了高性能的数据结构和算法，使编码更轻松，提高了程序速度和质量；
3.  可以方便地扩展或改写集合，提高代码复用性和可操作性。
4.  通过使用JDK自带的集合类，可以降低代码维护和学习新API成本。

#### 常用的集合类有哪些？ ####

*  Map接口和Collection接口是所有集合框架的父接口：

1.  Collection接口的子接口包括：Set接口和List接口
2.  Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等
3.  Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等
4.  List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等

#### List，Set，Map三者的区别？ ####

![6c0a033b7dde4a4085eb2021e7c14bc6.png][]

*  Java 容器分为 Collection 和 Map 两大类，Collection集合的子接口有Set、List、Queue三种子接口。我们比较常用的是Set、List，Map接口不是collection的子接口。
 *  Collection集合主要有List和Set两大接口
    
     *  List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。
     *  Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。
 *  Map是一个键值对集合，存储键、值和之间的映射。 Key无序，唯一；value 不要求有序，允许重复。Map没有继承于Collection接口，从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。
    
     *  Map 的常用实现类：HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap

#### 集合框架底层数据结构 ####

*  Collection
    
    1.  List
        
         *  Arraylist： Object数组
         *  Vector： Object数组
         *  LinkedList： 双向循环链表
    2.  Set
        
         *  HashSet（无序，唯一）：基于 HashMap 实现的，底层采用 HashMap 来保存元素
         *  LinkedHashSet： LinkedHashSet 继承与 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样，不过还是有一点点区别的。
         *  TreeSet（有序，唯一）： 红黑树(自平衡的排序二叉树。)
 *  Map
    
     *  HashMap： JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间
     *  LinkedHashMap：LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。
     *  HashTable： 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
     *  TreeMap： 红黑树（自平衡的排序二叉树）

#### 哪些集合类是线程安全的？ ####

*  Vector：就比Arraylist多了个 synchronized （线程安全），因为效率较低，现在已经不太建议使用。
 *  hashTable：就比hashMap多了个synchronized (线程安全)，不建议使用。
 *  ConcurrentHashMap：是Java5中支持高并发、高吞吐量的线程安全HashMap实现。它由Segment数组结构和HashEntry数组结构组成。Segment数组在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键-值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构；一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素；每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。（推荐使用）
 *  ...

#### Java集合的快速失败机制 “fail-fast”？ ####

*  是java集合的一种错误检测机制，当多个线程对集合进行结构上的改变的操作时，有可能会产生 fail-fast 机制。
 *  例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。
 *  原因：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
 *  解决办法：
    
    1.  在遍历过程中，所有涉及到改变modCount值得地方全部加上synchronized。
    2.  使用CopyOnWriteArrayList来替换ArrayList

#### 怎么确保一个集合不能被修改？ ####

*  可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。
 *  示例代码如下：
    
        List<String> list = new ArrayList<>();
        list. add("x");
        Collection<String> clist = Collections. unmodifiableCollection(list);
        clist. add("y"); // 运行时此行报错
        System. out. println(list. size());

### Collection接口 ###

#### List接口 ####

迭代器 Iterator 是什么？

*  Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration，迭代器允许调用者在迭代过程中移除元素。
 *  因为所有Collection接继承了Iterator迭代器

![format_png][]

Iterator 怎么使用？有什么特点？

*  Iterator 使用代码如下：
    
        List<String> list = new ArrayList<>();
        Iterator<String> it = list. iterator();
        while(it. hasNext()){
          String obj = it. next();
          System. out. println(obj);
        }
 *  Iterator 的特点是只能单向遍历，但是更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。

如何边遍历边移除 Collection 中的元素？

*  边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove() 方法，如下：
    
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
           *// do something*
           it.remove();
        }

一种最常见的**错误**代码如下：

for(Integer i : list){
       list.remove(i)
    }

*  运行以上错误代码会报 **ConcurrentModificationException 异常**。这是因为当使用 foreach(for(Integer i : list)) 语句时，会自动生成一个iterator 来遍历该 list，但同时该 list 正在被 Iterator.remove() 修改。Java 一般不允许一个线程在遍历 Collection 时另一个线程修改它。

Iterator 和 ListIterator 有什么区别？

*  Iterator 可以遍历 Set 和 List 集合，而 ListIterator 只能遍历 List。
 *  Iterator 只能单向遍历，而 ListIterator 可以双向遍历（向前/后遍历）。
 *  ListIterator 实现 Iterator 接口，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

遍历一个 List 有哪些不同的方式？每种方法的实现原理是什么？Java 中 List 遍历的最佳实践是什么？

*  遍历方式有以下几种：
    
    1.  for 循环遍历，基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后停止。
    2.  迭代器遍历，Iterator。Iterator 是面向对象的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。
    3.  foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。优点是代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。
 *  最佳实践：Java Collections 框架中提供了一个 RandomAccess 接口，用来标记 List 实现是否支持 Random Access。
    
     *  如果一个数据集合实现了该接口，就意味着它支持 Random Access，按位置读取元素的平均时间复杂度为 O(1)，如ArrayList。
     *  如果没有实现该接口，表示不支持 Random Access，如LinkedList。
     *  推荐的做法就是，支持 Random Access 的列表可用 for 循环遍历，否则建议用 Iterator 或 foreach 遍历。

说一下 ArrayList 的优缺点

*  ArrayList的优点如下：
    
     *  ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。
     *  ArrayList 在顺序添加一个元素的时候非常方便。
 *  ArrayList 的缺点如下：
    
     *  删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。
     *  插入元素的时候，也需要做一次元素复制操作，缺点同上。
 *  ArrayList 比较适合顺序添加、随机访问的场景。

如何实现数组和 List 之间的转换？

*  数组转 List：使用 Arrays. asList(array) 进行转换。
 *  List 转数组：使用 List 自带的 toArray() 方法。

*  代码示例：
    
        // list to array
        List<String> list = new ArrayList<String>();
        list.add("123");
        list.add("456");
        list.toArray();
        
        // array to list
        String[] array = new String[]{"123","456"};
        Arrays.asList(array);

ArrayList 和 LinkedList 的区别是什么？

*  数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
 *  随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。
 *  增加和删除效率：在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下标。
 *  内存空间占用：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。
 *  线程安全：ArrayList 和 LinkedList 都是不同步的

[6c0a033b7dde4a4085eb2021e7c14bc6.png]: https://img-blog.csdnimg.cn/6c0a033b7dde4a4085eb2021e7c14bc6.png
[format_png]: https://img-blog.csdnimg.cn/img_convert/d893cf04ee8347240c04e57bb765a677.webp?x-oss-process=image/format,png