Java集合容器面试题（面试必备）

文章目录

• • 1. 集合
  • • 1.1 什么是集合
    • 1.2 集合特点
    • 1.3 集合和数组得区别
    • 1.3 什么是集合框架
    • 1.4 集合框架的优点有哪些
    • 1.5 集合框架中的泛型有什么优点？
    • 1.6 常用的集合类
    • 1.5 哪些集合类是线程安全的？
    • 1.6 怎么确保一个集合不被修改？
    • 1.7 Java集合的快速失败机制 “fail-fast”？
    • 1.8 List如何一边遍历一边删除
  • 2.Collection接口
  • 2.1 List接口
  • • 2.1.1 Iterator是什么
    • 2.1.2 Iterator有什么特点，怎么使用
    • 2.1.3 如何一边遍历一边删除集合元素
    • 2.1.4 Iterator和ListIterator有什么区别
    • 2.1.5 遍历List的方式
    • 2.1.6 说下ArrayList的优缺点
    • 2.1.7 数组与List之间的转换
    • 2.1.8 ArrayList与LinkedList之间的区别
    • 2.1.9 ArrayList与Vector之间的区别
    • 2.1.10 插入数据ArrayList，LinkedList与Vector的性能
    • 2.1.11 多线程场景下使用ArrayList
    • 2.1.12 为什么ArrayList的elementData加上transient修饰
    • 2.1.13 List与Set的区别
  • 2.2 Set接口
  • • 2.2.1 说一下HashSet的实现原理
    • 2.2.2 说一下HashSet如何检查重复，如何保证数据不可重复？
    • 2.2.3 HashSet和HashMap的区别？
  • 2.3 Queue的poll()和remove()区别是什么
  • 3. Map接口
  • 4. 辅助工具类
  • • 4.1 comparable和comparator的区别
    • 4.2 Collection和Collections的区别

万恶之源：

1. 集合

1.1 什么是集合

集合是存储数据的容器，这里的数据指的是对象，可以存储不同的对象，并且长度可变。

1.2 集合特点

• 集合用于对象封装数据，存储对象
• 对象的个数可以确定时使用数组，不确定时使用集合，因为集合长度可变

1.3 集合和数组得区别

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

1.3 什么是集合框架

集合框架是为了操作集合而规定的一种标准的体系结构，任何集合框架都包括三大块内容：对外接口，接口实现，集合运算算法。
对外接口：即集合的抽象数据类型，接口提供了我们能够对集合提供的内容进行操作。
接口实现:也就是集合框架的接口的具体实现，实际上是哪些可以复用的数据结构。
集合运算算法:例如，查找，排序算法，都是一些可以复用的函数。

1.4 集合框架的优点有哪些

1. 降低核心类的开发成本，而非使用我们自己开发的集合类。
2. 通过使用JDK附带的集合类，可以降低开发成本。
3. 集合框架类经过严格的测试，开发质量会有所提高。
4. 容量自增长。

1.5 集合框架中的泛型有什么优点？

自从JDK 5发行后，引入的泛型编程，在集合类和接口中都在大量使用泛型，泛型提供可以容纳的对象类型，因此如果你添加了其它的对象类型，会出现类之间的转换异常，编译时就会报错ClassCastException，有些错误就可以避免，这样就会给运行时带来好处。

1.6 常用的集合类

Map接口和Collection接口是所有集合类的父接口

1. Collection：实现接口主要有Set，List，Queue
2. Map：实现接口主要有Hashtable，HashMap，TreeMap，ConcurrentHashMap以及Properties
3. Set接口主要实现类有Hashset，SortSet，LinkedHashSet
4. List接口主要实现有ArrayList，LinkedList，Vector

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

• Vector就比ArrayList多了个同步机制（线程安全）但因为效率低，已经很少被使用了。
• Stack：堆栈类，先进后出
• HashTable：就比HashMap多了个线程安全
• enumeration：枚举，相当于迭代器

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

可以使用Colections工具类的方法，任何集合对象经过处理都不能被修改
否则就会抛出异常

        List<String> list = new ArrayList<>();
        list.add("x");
        Collection<String> collection = Collections.unmodifiableCollection(list);
        collection.add("y");
        System.out.println(collection.size());

Exception in thread "main" java.lang.UnsupportedOperationException

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

fail-fast是Java的一种错误检测机制，当多线程对集合上的结构进行操作时，就可能产生fail-fast机制。
出现场景：
假如存在两个线程（线程1，线程2），线程1通过Iterator在遍历集合A的元素，在某个线程2中修改了集合的结构（不是单纯的修饰其内容），那么这个时候程序就会抛出CurrentModificationException异常，从而产生fail-fast机制。
原因：
迭代器在遍历时直接访问集合中的内容，并且在遍历的时候使用一个modCount变量，集合在被遍历的过程中，如果内容发生变化（如元素被删除），则modCount就会发生改变。每次迭代器使用hashNext()/next()遍历下一个元素之前，就会先比较mCount是否与expectedModCount相等，expectedModCount默认值等于集合元素的个数，如果是就返回遍历，不是的话就抛出异常。

解决方法：

• 在遍历过程是，所有涉及改变modCount的值的地方全部加上synchronized
• 使用CopyOnWriteArrayList(线程安全)来替换ArrayList
  
  更多CopyOnWriteArrayList：

https://baijiahao.baidu.com/s?id=1666117483794506320&wfr=spider&for=pc

1.8 List如何一边遍历一边删除

先说说我们可能会犯的错误

   List<Integer> list = new ArrayList<Integer>();
   list.add(11);
   list.add(22);
   list.add(33);

 for (Integer integer : list) {
   
       list.remove(integer);
   }

如此我们会犯什么错了，看上去好像没错，但是运行之后就会产生上面1.8处说明的fail-fast机制，报出ConcurrentModificationException
产生的原因：和上面分析分析一致，foreach遍历其实内部采用的就是Iterator的遍历思想，当迭代器（线程1）在遍历的时候会维护着一个modCount遍历，但是如果list.remove(integer)（线程2）进行集合结构内容的改变时，就会改变modCount值，影响到迭代器遍历，爆出线程并发异常。
解决方法：除了上面提到的两个外这边可以直接使用迭代器的删除方法，如下：

   List<Integer> list = new ArrayList<Integer>();
   list.add(11);
   list.add(22);
   list.add(33);

   Iterator<Integer> it = list.iterator();
   while (it.hasNext()){
   
        Integer next = it.next();
        System.out.println(next);
       it.remove();
   }

注意：Iterator对象开始的cursor（游标）是指向0，类似于头指针，hasNext查看有没有下一个元素，所以it.next();不能放remove下方。

2.Collection接口

2.1 List接口

2.1.1 Iterator是什么

迭代器Iterator接口提供遍历任何Collection接口， public interface Collection<E> extends Iterable<E>，我们可以从Collection中使用迭代器方法获取迭代器实例，迭代器允许Java集合在遍历的时候删除元素。

2.1.2 Iterator有什么特点，怎么使用

   List<Integer> list = new ArrayList<Integer>();
   list.add(11);
   list.add(22);
   list.add(33);

   Iterator<Integer> it = list.iterator();
   while (it.hasNext()){
   
        Integer next = it.next();
        System.out.println(next);
   }

Iterator特点是单向遍历，但是更加安全，它可以保证当前正在遍历集合元素被修改的时候，爆出并发异常ConcurrentModificationException

2.1.3 如何一边遍历一边删除集合元素

### 1.8 List如何一边遍历一边删除

2.1.4 Iterator和ListIterator有什么区别

• Iterator可以遍历List和Set的集合，而ListIterator只能遍历L集合
• Iterator只支持单向遍历，而ListIterator支持双向遍历（前/后）
• ListIterator实现Iterator接口，又添加了一些额外功能，如添加一个元素，替换一个元素。

2.1.5 遍历List的方式

遍历方法：

1. for循环遍历：基于计数器，集合外部维护着一个计数器，然后依次读取每个元素，直到读到最后一个元素即可。
2. Iterator遍历：Iterator是面向对象的一种设计模式，目的是屏蔽不同集合的特点，统一遍历集合接口，Collectioin中采用的迭代器模式。
3. foreach：内部还是使用了迭代器的方式实现，使用时不需要显示的声明迭代器或计数器，优点时代码简洁，不易出错，缺点是，在遍历的时候不能操作集合，如增删改，否则报会并发异常。

最佳方法：Java Collection接口中提供了RandomAccess 接口，用于标记集合是否支持RandomAccess接口

1. 如果一个集合实现了该接口，则它支持快速随机访问，按位置读取元素的平均时间复杂度是O(1)，如ArrayList
2. 如果集合没有实现该接口，表示不支持RandomAccess接口，如LinkedList
   综上：推荐的做法是，如果集合支持RandomAccess可以使用for遍历，否则使用Iterator/foreach遍历。

2.1.6 说下ArrayList的优缺点

优点：

• ArrayList底层采用数组实现，是一种随机的访问模式，并且实现了RandomAccess接口，因此查找的速度非常快。
• ArrayList顺序添加元素非常方便

缺点：

• 删除元素的时候需要做元素的复制操作，如果元素的很多的话，很消耗性能。
• 插入元素的时候，同样遇到上面的问题，移动移动元素，让出插入位置。

2.1.7 数组与List之间的转换

• 数组转List：使用Arrays.asList方法
• List转数组：使用toArray方法

 List<Integer> list = new ArrayList<Integer>();
 list.add(11);
 list.add(22);
 list.add(33);

 Object[] objects = list.toArray();  //list->[]

 String []strs = new String[]{
   "aa","bb"};
 List<String> strings = Arrays.asList(strs);   //[]->list

2.1.8 ArrayList与LinkedList之间的区别

数据结构：ArrayList底层采用的是数组实现，LinkedList采用双向链表实现。
数据访问：ArrayList要优于LinkedList，因为ArrayList底层采用数组实现，LinkedList采用线性的链式存储结构，需要移动指针来访问。
增删效率：LinkedList要优于ArrayList，ArrayList增删要复制元素，影响其它数组元素的下标，而LinkedList只需要移动指针。
线程安全：ArrayList和LinkedList都是线程不同步的，都不能保证线程安全。

综上：如果对集合元素增删比较频繁的话推荐使用LinkedList，查找比较频繁的话推荐使用ArrayList。

2.1.9 ArrayList与Vector之间的区别

ArrayList与Vector都是List接口的实现，List接口又实现了Collection接口，因此ArrayList与Vector都是有序的集合。

• Vector相比ArrayList更为安全，因此它增加了Synchronized来实现线程同步，因此是线程安全的，而ArrayList线程不安全。
• ArrayList的性能要优于Vector

综上：追求效率至上不需要保证线程安全的情况下推荐使用ArrayList，需要线程安全的情况下推荐Vector

2.1.10 插入数据ArrayList，LinkedList与Vector的性能

ArrayList和Vector底层都是采用数组实现，Vector相比ArrayList加入了线程安全机制，相比ArrayList更为安全，但是效率却不及ArrayList，它们都不适合用频繁增删集合元素，因此会影响到集合内的其它元素。
LinkedList底层采用双向链表实现，增删元素靠指针来完成，不会影响到集合内的其它元素，因此效率更高。

2.1.11 多线程场景下使用ArrayList

由于ArrayList非线程安全，多线程的场景下使用ArrayList，可能会出现问题，可以使用Collections的synchronizedList方法将其转成一个线程安全的List再使用

  List<Integer> list = new ArrayList<Integer>();
  list.add(11);
  list.add(22);
  list.add(33);

  List<Integer> integers = Collections.synchronizedList(list);
  integers.add(44);

2.1.12 为什么ArrayList的elementData加上transient修饰

transient Object[] elementData; // non-private to simplify nested class access

回答问题前必须先明确transient的作用是什么？
持久化对象是，如果一个对象不想用序列化的机制来保存它，就可以在前面加一个transient。
回到刚刚的问题elementData前面加上transient说明elementData不会被序列化。这样做又什么好处呢？请看ArrayList中两个重要的函数

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
   
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();
 
    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);
 
    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
   
        s.writeObject(elementData[i]);
    }
 
    if (modCount != expectedModCount) {
   
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
   
    elementData = EMPTY_ELEMENTDATA;
 
    // Read in size, and any hidden stuff
    s.defaultReadObject();
 
    // Read in capacity
    s.readInt(); // ignored
 
    if (size > 0) {
   
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);
 
        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
   
            a[i] = s.readObject();
        }
    }
}

elementData是ArrayList存储元素的数组，是一个缓存数组，它通常会预留一些空间，等容量不足再进行扩容。每次序列化时，先调用defaultWriteObject方法来序列化ArrayList中哪些非transient修饰的内容，然后遍历elementData，用readObject和writeObject方法来实序列化就可以保证之序列化哪些实际存储的元素，从不是整个数组，从而节省了序列化过程中的空间和时间。

参考：https://blog.csdn.net/weixin_33924220/article/details/92348708

2.1.13 List与Set的区别

List和Set都继承于Collection接口
特点
List：一个有序的（存入和取出的顺序一致）的容器，可以插入null值，可以又重复元素，元素都有索引，常用的实现类有ArrayList，LinkedList，Vector.
Set：一个无序的（存入和取出的顺序可能不一致）的容器，不允许重复元素，只允许存入一个null，必须保证元素的唯一性，Set常见的实现类有HashSet，LinkedHashSet，TreeSet.
遍历
List因为是有序的，所以支持使用for,也就是通过下标来遍历，迭代器遍历，而Set只支持迭代器遍历，因为它是无序的，无法通过下标来获取值。

2.2 Set接口

2.2.1 说一下HashSet的实现原理

HashSet是基于HashMap实现的，HashSet的值存放在HashMap的key上，相关HashSet的操作，基本上都是直接调用底层的HashMap的相关方法来实现的，并且HashSet不可重复，是无序的。

2.2.2 说一下HashSet如何检查重复，如何保证数据不可重复？

说在前面：HashSet是Set的实现，不是Map接口下的实现。。。。
HashSet的add方法底层使用HashMap的put方法来插入数据，判断数据是否存在的依据，不仅要比较hashcode值还要equals方法。
HashSet部分源码：

private static final Object PRESENT = new Object();
private transient HashMap<E,Object> map;

public HashSet() {
   
    map = new HashMap<>();
}

public boolean add(E e) {
   
    // 调用HashMap的put方法,PRESENT是一个至始至终都相同的虚值
	return map.put(e, PRESENT)==null;
}

HashMap的key是唯一的，由源码可知HashSet的key就是使用HashMap的key，如果HashSet中遇到相同的key时，对于新的value就会覆盖旧的value，返回旧的value，所以是不会重复的。
HashMap比较key是否相等是先比较hashcode，再equals。

<mark>回顾hashcode和equals。</mark>
Java对hashcode()和equals()有以下规定：

1. 如果两个对象相等，则它们的hashcode()一定相等
2. 如果两个对象相等，则它们的equals也返回true
3. 如果两个对象的hashcode相等，但是它们不一定相等。

综上：我们再重写equals时，规定也必须重写hashcode
hashcode()的默认行为是对堆上的对象产生独特值，如果没有重写hashcode()，无论如何两个对象都不会相等（即使两个对象指向相同的数据）
== 与 equals的区别

• == 是判断两个变量或实例是否指向相同的内存地址，equals是判断两个变量或实例指向的内存地址对应的值是否相等
• ==是对内存地址进行比较，equals是对字符串进行比较
• ==是比较引用是否相同，equals是值是否相同

2.2.3 HashSet和HashMap的区别？

2.3 Queue的poll()和remove()区别是什么

  Queue<String> queue = new LinkedList<>();
        queue.offer("11");
// System.out.println(queue.poll()); //11
// System.out.println(queue.poll()); //null
        System.out.println(queue.remove()); //11
        System.out.println(queue.remove()); //java.util.NoSuchElementException

区别已经很明显了

• 相同点：poll()和remove()都是删除队列元素并返回删除元素
• 不同点：当队列中没有元素时remove会抛出异常java.util.NoSuchElementException，而poll返回null

3. Map接口

https://blog.csdn.net/JAYU_37/article/details/104433085

4. 辅助工具类

4.1 comparable和comparator的区别

1. comparable在java.lang.Comparable它有一个comparaTo方法用于排序；comparator在java.util包中，它有一个compare(Object obj1,Object obj2)用于排序
2. 如果实现类没有实现comparable接口或者实现了comparable接口但是不满足于comparable接口提供的compareTo方法，我们可以自定义比较方法，只需要实现Comparator接口重写compare(Object obj1,Object obj2)方法。
3. comparable需要比较对象来实现接口，使用对象调用方法来比较对象，需要改变对象内部结构(重写compareTo)，耦合度高。comparator相当于一个通用的比较工具接口，需要定制一个比较类去实现它，重写里面的compare方法，方法参数即比较的对象，对象不用做任何的改变，解耦。

4.2 Collection和Collections的区别

Collection是java.utils.Collectioni的集合接口，也是集合的顶级接口，它提供了对集合对象的基本操作和通用方法，Collection类在Java类库中有很多体现，直接实现类有List，Set。
Collections：是集合类的一个工具类，提供了一系列的静态方法，用于对集合中的元素进行排序，搜索等操作。