写点什么

Java 集合容器篇面试题(上,Java 中高级程序员进阶

发布于: 4 小时前

例如:假设存在两个线程(线程 1、线程 2),线程 1 通过 Iterator 在遍历集合 A 中的元素,


在某个时候线程 2 修改了集合 A 的结构(是结构上面的修改,而不是简单的修改集合元素的内容),那么这个时候程序就会抛出 ConcurrentModificationException 异常,从而产生 fail-fast 机制。


原因:迭代器在遍历时直接访问集合中的内容,并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化,就会改变 modCount 的值。每当迭代器使用 hashNext()/next()遍历下一个元素之前,都会检测 modCount 变量是否为 expectedmodCount 值,是的话就返回遍历;否则抛出异常,终止遍历。


解决办法:


1. 在遍历过程中,所有涉及到改变 modCount 值得地方全部加上 synchronized。


2. 使用 CopyOnWriteArrayList 来替换 ArrayList


1.10 怎么确保一个集合不能被修改?




可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合,这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。


示例代码如下:



List list = new ArrayList<>();
list. add("x");
Collection clist = Collections.unmodifiableCollection(list);
clist. add("y"); // 运行时此行报错
System. out. println(list. size());
复制代码


二 、Collection 接口


===========================


2.1 List 接口




2.1.1 迭代器 Iterator 是什么?


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


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


Iterator 使用代码如下:



public static void main(String[] args) throws IOException {
List list = new ArrayList<>();
Iterator it = list.iterator();
while (it.hasNext()) {
String obj = (String) it.next();
System.out.println(obj);
}


}
复制代码


Iterator 的特点是只能单向遍历,但是更加安全,因为它可以确保,在当前遍历的集合元素被更改的时候,就会抛出 ConcurrentModificationException 异常。


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


边遍历边修改 Collection 的唯一正确方式是使用 Iterator.remove() 方法


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



for(Integer i : list){
list.remove(i)
}
复制代码


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


2.1.4 Iterator 和 ListIterator 有什么区别?


? Iterator 可以遍历 Set 和 List 集合,而 ListIterator 只能遍历 List。


? Iterator 只能单向遍历,而 ListIterator 可以双向遍历(向前/后遍历)。


? ListIterator 实现 Iterator 接口,然后添加了一些额外的功能,比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。


2.1.5 遍历一个 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 遍历。


2.1.6 说一下 ArrayList 的优缺点


?ArrayList 的优点如下:


ArrayList 底层以数组实现,是一种随机访问模式。ArrayList 实现了 RandomAccess 接口,因此查找的时候非常快。


ArrayList 在顺序添加一个元素的时候非常方便。


ArrayList 的缺点如下:


删除元素的时候,需要做一次元素复制操作。如果要复制的元素很多,那么就会比较耗费性能。


插入元素的时候,也需要做一次元素复制操作,缺点同上。


ArrayList 比较适合顺序添加、随机访问的场景。


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


数组转 List:使用 Arrays. asList(array) 进行转换。


List 转数组:使用 List 自带的 toArray() 方法。


代码示例:



String[] strs = new String[] {"aaa", "bbb", "ccc"};
List<String> list = Arrays.asList(strs);
for (String s : list) {
System.out.println(s);
}
复制代码


2.1.8 ArrayList 和 LinkedList 的区别是什么?


数据结构实现:ArrayList 是动态数组的数据结构实现,而 LinkedList 是双向链表的数据结构实现。


随机访问效率:ArrayList 比 LinkedList 在随机访问的时候效率要高,因为 LinkedList 是线性的数据存储方式,所以需要移动指针从前往后依次查找。


增加和删除效率:在非首尾的增加和删除操作,LinkedList 要比 ArrayList 效率要高,因为 ArrayList 增删操作要影响数组内的其他数据的下标。


内存空间占用:LinkedList 比 ArrayList 更占内存,因为 LinkedList 的节点除了存储数据,


还存储了两个引用,一个指向前一个元素,一个指向后一个元素。


线程安全:ArrayList 和 LinkedList 都是不同步的,也就是不保证线程安全;


综合来说,在需要频繁读取集合中的元素时,更推荐使用 ArrayList,而在插入和删除操作较多时,更推荐使用 LinkedList。


补充:数据结构基础之双向链表双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接


后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。


2.1.9 ArrayList 和 Vector 的区别是什么?


这两个类都实现了 List 接口(List 接口继承了 Collection 接口),他们都是有序集合


线程安全:Vector 使用了 Synchronized 来实现线程同步,是线程安全的,而 ArrayList 是非线程安全的。


性能:ArrayList 在性能方面要优于 Vector。


扩容:ArrayList 和 Vector 都会根据实际的需要动态的调整容量,只不过在 Vector 扩容每次会增加 1 倍,而 ArrayList 只会增加 50%。


Vector 类的所有方法都是同步的。可以由两个线程安全地访问一个 Vector 对象、但是一个线程访问 Vector 的话代码要在同步操作上耗费大量的时间。


Arraylist 不是同步的,所以在不需要保证线程安全时时建议使用 Arraylist。


2.1.10 插入数据时,ArrayList、LinkedList、Vector 谁速度较快?阐述 ArrayList、Vector、LinkedList 的存储性能和特性?


ArrayList、LinkedList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢。


Vector 中的方法由于加了 synchronized 修饰,因此 Vector 是线程安全容器,但性能上较 ArrayList 差。


LinkedList 使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但插入数据时只需要记录当前项的前后项即可,所以 LinkedList 插入速度较快。


2.1.11 多线程场景下如何使用 ArrayList?


ArrayList 不是线程安全的,如果遇到多线程场景,可以通过 Collections 的


synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样:



List <String>list=new ArrayList<String>();
List<String> synchronizedList = Collections.synchronizedList(list);
synchronizedList.add("aaa");
synchronizedList.add("bbb");
for (int i = 0; i < synchronizedList.size(); i++) {
System.out.println(synchronizedList.get(i));
}
复制代码


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


ArrayList 中的数组定义如下:



private transient Object[] elementData;
复制代码


再看一下 ArrayList 的定义:



public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}
复制代码


可以看到 ArrayList 实现了 Serializable 接口,这意味着 ArrayList 支持序列化。


transient 的作用是说不希望 elementData 数组被序列化,重写了 writeObject 实现:



private void writeObject(java.io.ObjectOutputStream s){
try {
s.writeObject(name);
s.writeObject(age);
System.out.println("重写了writeObject");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
复制代码


每次序列化时,先调用 default WriteObject() 方法序列化 ArrayList 中的非 transient 元素,然后遍历 elementData,只序列化已存入的元素,这样既加快了序列化的速度,又减小了序列化之后的文件大小。


2.1.13 List 和 Set 的区别


List , Set 都是继承自 Collection 接口


List 特点:一个有序(元素存入集合的顺序和取出的顺序一致)容器,元素可以重复,可以插入多个 null 元素,元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。


Set 特点:一个无序(存入和取出顺序有可能不一致)容器,不可以存储重复元素,只允许存入一个 null 元素,必须保证元素唯一性。Set 接口常用实现类是 HashSet、


LinkedHashSet 以及 TreeSet。


另外 List 支持 for 循环,也就是通过下标来遍历,也可以用迭代器,但是 set 只能用迭代,


因为他无序,无法用下标来取得想要的值。


Set 和 List 对比


Set:检索元素效率低下,删除和插入效率高,插入和删除不会引起元素位置改变。


List:和数组类似,List 可以动态增长,查找元素效率高,插入删除元素效率低,因为会引起其他元素位置改变


2.2 Set 接口




2.2.1 说一下 HashSet 的实现原理?


HashSet 是基于 HashMap 实现的,HashSet 的值存放于 HashMap 的 key 上,HashMap 的 value 统一为 PRESENT,因此 HashSet 的实现比较简单,相关 HashSet 的操作,基本上都是直接调用底层 HashMap 的相关方法来完成,HashSet 不允许重复的值。


2.2.2 HashSet 如何检查重复?HashSet 是如何保证数据不可重复的?


向 HashSet 中 add ()元素时,判断元素是否存在的依据,不仅要比较 hash 值,同时还要结合 equles 方法比较。


HashSet 中的 add ()方法会使用 HashMap 的 put()方法。


HashMap 的 key 是唯一的,由源码可以看出 HashSet 添加进去的值就是作为 HashMap 的 key,并且在 HashMap 中如果 K/V 相同时,会用新的 V 覆盖掉旧的 V,然后返回旧的 V。所以不会重复( HashMap 比较 key 是否相等是先比较 hashcode 再比较 equals )。


以下是 HashSet 部分源码:



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


public testCSDN198() {


map = new HashMap<>();


}


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


return map.put(e, PRESENT) == null;


}
复制代码


hashCode()与 equals()的相关规定:


1. 如果两个对象相等,则 hashcode 一定也是相同的


2. 两个对象相等,对两个 equals 方法返回 true


3. 两个对象有相同的 hashcode 值,它们也不一定是相等的


4. 综上,equals 方法被覆盖过,则 hashCode 方法也必须被覆盖


5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode(),则该 class 的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。


==与 equals 的区别


1. ==是判断两个变量或实例是不是指向同一个内存空间 equals 是判断两个变量或实例所指向的内存空间的值是不是相同


2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较 3.==指引用是否相同 equals()指的是值是否相同


2.2.3 HashSet 与 HashMap 的区别


<table border="1" cellpadding="1" cellspacing="1"><tbody><tr><td style="width:292px;">HashMap*</td><td style="width:485px;">HashSet</td></tr><tr><td style="width:292px;">HashMap 实现了 Map 接口</td><td style="width:485px;">HashSet 实现了 Set 接口</td></tr><tr><td style="width:292px;">HashMap 储存键值对</td><td style="width:485px;">HashSet 仅仅存储对象</td></tr><tr><td style="width:292px;">使用 put()方法将元素放入 map 中</td><td style="width:485px;">使用 add()方法将元素放入 set 中</td></tr><tr><td style="width:292px;">HashMap 中使用键对象来计算 hashcode 值</td><td style="width:485px;">HashSet 使用成员对象来计算 hashcode 值,对于两个对象来说 hashcode 可能相同,所以 equals()方法用来判断对象的相等性,如果两个对象不同的话,那么返回 false</td></tr><tr><td style="width:292px;">HashMap 比较快,因为是使用唯一的键来获取对象</td><td style="width:485px;">HashSet 较 HashMap 来说比较慢</td></tr></tbody></table>


2.3 Queue




2.3.1BlockingQueue 是什么?


Java.util.concurrent.BlockingQueue 是一个队列,在进行检索或移除一个元素的时候,


它会等待队列变为非空;当在添加一个元素时,它会等待队列中的可用空间。


BlockingQueue 接口是 Java 集合框架的一部分,主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间,或消费者有可用的对象,因为它都在 BlockingQueue 的实现类中被处理了。Java 提供了集中 BlockingQueue 的实现,


比如 ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue 等。


在 Queue 中 poll()和 remove()有什么区别?


? 相同点:都是返回第一个元素,并在队列中删除返回的对象。


? 不同点:如果没有元素 poll()会返回 null,而 remove()会直接抛出 NoSuchElementException 异常。


代码示例:



Queue queue = new LinkedList();
queue.offer("string");
System. out. println(queue.poll());
System. out. println(queue. remove());
System. out. println(queue. size());
复制代码



下一期:介绍 Java 集合容器篇面试题(下)





Java 项目实战分享:





基于java+springboot+mybatis+laiyu实现学科竞赛管理系统



基于java ssm springboot+VUE疫情防疫系统系统前后端分离设计和实现



基于java springboot+mybatis电影售票网站管理系统前台+后台设计和实现



基于java ssm springboot+mybatis酒庄内部管理系统设计和实现



基于JAVA springboot+mybatis智慧生活分享平台设计和实现



基于Java springboot+vue+redis前后端分离家具商城平台系统设计和实现



基于JAVA SSM springboot实现的抗疫物质信息管理系统设计和实现


最后

总而言之,面试官问来问去,问的那些 Redis 知识点也就这么多吧,复习的不够到位,知识点掌握不够熟练,所以面试才会卡壳。将这些 Redis 面试知识解析以及我整理的一些学习笔记分享出来给大家参考学习


有需要这些学习笔记资料的朋友注意啦:戳这里即可免费领取


还有更多学习笔记面试资料也分享如下(都可免费领取):



用户头像

VX:Lzzzzzz63 领取资料 2021.07.07 加入

还未添加个人简介

评论

发布
暂无评论
Java 集合容器篇面试题(上,Java中高级程序员进阶