Java 基础学习（十三）集合框架、List集合
1 集合框架
1.1 Collection
1.1.1 集合框架概述
Java 集合框架是一组实现了常见数据结构（如列表、树集和哈希表等）的类和接口，用于存储一组数据。
开发者在使用Java的集合类时，不必考虑数据结构和算法的具体实现细节，根据场景需要直接选择并使用这些集合类，调用相应的方法即可，从而提高开发效率。
例如，开发者可以创建一个基于数组结构的集合对象，然后调用该对象的add方法向集合中添加元素，或者调用该对象的get方法从集合中获取某个已添加的元素。
?Java的集合中存储的都是引用类型的元素，由于引用类型变量实际上存储的是对象的“地址”，集合中实际上只存储了元素对象在堆中的地址，而并不是将对象本身存入了集合中。
?
Java所有的集合类都位于java.util包中，按照存储结构可以分为两大类，即单列集合和双列集合。单列集合是指集合中的元素是单个对象，双列集合是指集合中的元素以键值对（key-value pair）的形式存在。Collection是单列集合的根接口，Map是双列集合的根接口，各自还派生出一些子接口或实现类。
1.1.2 Collection集合体系
Collection集合体系的架构图如下图所示：
Collection接口有3个子接口：
- List接口：有序且可以重复的集合
- Set接口：无序且不可重复的集合
- Queue接口：队列集合，用来存储满足FIFO（First In First Out）原则的容器
有序和无序：指集合中的元素是否能保存元素的添加顺序。例如，将3个整型元素5、3、9添加到集合中，List集合能够保证按照5、3、9的顺序访问元素，而Set集合无法保证能按这一顺序访问。
是否可重复：指集合中是否允许有重复的元素，重复元素指的并非是同一个元素，而是指equals方法比较为true的元素。
1.1.3 Collection接口的主要方法
在Collection中定义了单列集合的一些通用方法，使用这些方法可以操作所有的单列集合。
?
1.1.4 【案例】add方法示例
编写代码，测试Collection的add方法。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
Collection c = new ArrayList();
System.out.println(c); // []
c.add("张亚峰");
c.add("刘苍松");
c.add(666);
System.out.println(c); // [张亚峰, 刘苍松, 666]
}
}1.1.5 contains方法
contains() 方法用于判断给定的元素是否被包含在集合中。语法如下：
boolean contains(Object o)若包含则返回true，否则返回false。
这里需要注意的是，集合在判断元素是否被包含在集合中是根据每个元素的equals() 方法进行比较后的结果。因此，通常有必要重写 equals() 保证 contains() 方法返回合理的结果。
1.1.6 【案例】contains方法示例
编写代码，测试Collection的contains方法。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new String("hello"));
// List集合contains方法和对象的equals方法相关
boolean flag = c.contains("hello");
System.out.println("flag: " + flag); // flag: true
System.out.println("flag: " + c.contains("hell")); // flag: false
}
}1.1.7 size、clear、isEmpty方法
Collection集合还有3个常用的方法：
- int size()：该方法用于返回当前集合中的元素总数
- void clear()：该方法用于清空当前集合
- boolean isEmpty()：该方法用于判断当前集合中是否不包含任何元素
1.1.8 【案例】size、clear、isEmpty方法示例
编写代码，测试Collection的size、clear和isEmpty方法。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo3 {
public static void main(String[] args) {
Collection c = new ArrayList();
System.out.println(c.isEmpty()); // true
c.add("java");
c.add("c++");
c.add("php");
c.add("c#");
c.add("python");
// isEmpty:false, size: 5
System.out.println("isEmpty:" + c.isEmpty() + ",size: " + c.size());
// 清空集合
c.clear();
// isEmpty:true, size: 0
System.out.println("isEmpty:" + c.isEmpty() + ", size: " + c.size());
}
}1.1.9 addAll与containsAll 方法
如果需要将一个集合加入另一个集合，可以使用 addAll() 方法：
boolean addAll(Collection<? extends E> c)该方法需要传入一个集合，并将该集合中的所有元素添加到当前集合中。如果此 collection 由于调用而发生更改，则返回 true。
如果希望判断当前集合是否包含给定集合中的所有元素，可以使用containsAll() 方法：
boolean containsAll(Collection<?> c)若包含则返回 true。
1.1.10 【案例】addAll与containsAll方法示例
编写代码，测试Collection的addAll和containsAll方法。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo4 {
public static void main(String[] args) {
Collection passedStudentList = new ArrayList(); // 考试通过的学生名单
passedStudentList.add("Alice");
passedStudentList.add("Bob");
passedStudentList.add("Lucy");
passedStudentList.add("Lily");
Collection groupAList = new ArrayList<>(); // A组学生名单
groupAList.add("Bob");
groupAList.add("Tony");
// A组学生是否都通过了考试
boolean passed = passedStudentList.containsAll(groupAList);
if (passed) {
System.out.println("A组全部通过了考试！");
} else {
System.out.println("A组没有全部通过了考试！");
}
// B组学生名单
Collection groupBList = new ArrayList<>();
groupBList.add("Tom");
groupBList.add("Jerry");
// 将B组学生名单添加到考试通过的学生名单中
passedStudentList.addAll(groupBList);
}
} 1.2 Iterator迭代器
1.2.1 迭代器概述
迭代器（Iterator）接口是Java集合框架中的一员，诞生于JDK 1.2版本，主要用于迭代访问（即遍历）Collection中的元素，因此，Iterator对象也被称为迭代器。
获取迭代器的方式是使用Collection定义的iterator方法：
?
迭代器Iterator是一个接口，集合在覆盖Collection的iterator()方法时提供了迭代器的具体实现。
1.2.2 迭代器接口的主要方法
迭代器（Iterator）接口中定义了4个方法。
最常用的方法为：
- hasNext：用于判断当前迭代中是否有更多元素
- next：返回当前迭代中的下一个元素
- remove：从集合中移除最近一次调用next方法时返回的那个元素，与next方法搭配使用
三个方法的操作示意如下图所示：
?注意：
- 遍历过程中不能直接通过Collection的 remove() 方法删除集合元素，否则会抛出并发更改异常
- 在调用 迭代器的remove() 方法前必须通过迭代器的 next() 方法迭代过元素，那么删除的就是这个元素
- 调用一次next()方法后只能调用一次remove()方法
1.2.3 【案例】Iterator示例
编写代码，测试Iterator的hasNext、next和remove方法。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo1 {
public static void main(String[] args) {
Collection c = new ArrayList();
// 向集合中添加1到10
for (int i = 1; i <= 10; i++){
c.add(i);
}
System.out.println(c);
// 获取集合的迭代器对象
Iterator itr = c.iterator();
// 通过迭代器遍历集合
while (itr.hasNext()) {
int i = (int)itr.next();
System.out.print(i + " ");
// 通过迭代器删除集合中的元素
if (i % 2 != 0){
itr.remove();
}
}
System.out.println();
// 输出集合中的元素
System.out.println(c);
}
}1.2.4 增强for循环
增强for循环是Java 1.5之后推出了一个新的特性，用于简化集合的遍历操作。语法如下：
for(元素类型 e : 集合或数组){
循环体
}增强for循环会按照从头到尾的顺序逐个访问集合或数组中的元素，变量e的值与集合或数组中当前访问的元素的值相同。例如，使用增强for循环访问一个包含了“a”，“b”“c”三个元素的集合，第一次循环时，e的值为“a”，第二次循环时，e的值为“b”，以此类推。
增强for循环并非新的语法，而是在编译过程中，编译器会将增强for循环转换为迭代器模式。所以增强for循环本质上是迭代器。
1.2.5 【案例】增强for循环示例
编写代码，测试增强的for循环的使用。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo2 {
public static void main(String[] args) {
Collection c = new ArrayList();
// 向集合中添加1到10
for (int i = 1; i <= 10; i++){
c.add(i);
}
// 使用增强for循环遍历集合中的元素
for(Object o : c){
System.out.print(o +" ");
}
System.out.println();
// 也可用于遍历数组
String[] array = {"Tom", "Bob", "Jerry"};
for(String s: array){
System.out.println(s);
}
}
}1.3 泛型机制
1.3.1 泛型概述
泛型（Generic）是Java从JDK 1.5开始引入的，可以帮助用户建立类型安全的集合。泛型的本质就是“数据类型的参数化”。可以把泛型理解为数据类型的一个占位符（形式参数），即在编写代码时将数据类型定义成参数，这些类型参数在使用或调用时传入具体的类型。
在JDK 1.5之前，为了实现参数类型的任意化，都是通过Object类型来处理的。但这种处理方式的缺点是需要进行强制类型转换，这种强制类型转换不仅使代码臃肿，还要求开发者必须在已知实际使用的参数类型的情况下才能进行，否则容易引起ClassCastException异常。
使用泛型的好处是在程序编译期间会对类型进行检查，捕捉类型不匹配错误，以免引起ClassCastException异常；在使用了泛型的集合中，遍历时不必进行强制类型转换，数据类型都是自动转换的。
?泛型也经常在类、接口和方法的定义中使用，这部分内容将在后续的课程中进行讲解。
1.3.2 【案例】泛型示例
编写代码，测试泛型的使用。代码示意如下：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericDemo1 {
public static void main(String[] args) {
// 使用泛型指定集合中元素为Integer类型
Collection<Integer> c = new ArrayList<>();
c.add(123);
// c.add("abc"); // 编译时报错，类型不匹配
Iterator<Integer> itr = c.iterator();
while (itr.hasNext()) {
// 无需类型转换
int i = itr.next();
System.out.print(i + " ");
}
}
} 2 List集合
2.1 List接口
2.1.1 List接口概述
List接口继承自Collection接口，是单列集合的一个重要分支；将实现了List接口的对象称为List集合。List接口的特点可简单总结为“有序可重复”。
List接口不但继承了Collection接口中的全部方法，而且增加了一些操作集合的特有方法：
?
2.2 ArrayList
2.2.1 ArrayList概述
ArrayList是List接口的一个实现类，是程序中最常见的一种集合。在ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组长度时，ArrayList会在内存空间中创建一个更大的数组来存储这些元素。
?
ArrayList的主要特点如下：
1、动态大小：ArrayList的大小是可以动态增长和缩小的。与普通的数组相比，ArrayList不需要指定初始大小，并且可以根据需要自动调整容量。
2、随机访问：ArrayList通过索引来访问集合中的元素。由于ArrayList使用了数组实现，因此可以通过索引以常量时间复杂度（O(1)）来获取元素。这使得ArrayList非常适合需要频繁随机访问元素的场景。
3、允许重复元素：ArrayList可以包含重复的元素。这意味着可以多次添加相同的元素到ArrayList中。
4、支持动态修改：ArrayList提供了一系列方法来修改集合中的元素，如添加、删除、插入和替换等操作。通过这些方法，可以方便地对集合进行修改。
5、迭代和遍历：ArrayList实现了Iterable接口，因此可以使用迭代器（Iterator）或者增强型for循环来遍历集合中的元素。
2.2.2 ArrayList常用方法
除了从Collection接口间接继承的方法外，ArrayList中还包含以下常用方法。
1、void add(int index, E element)：将给定的元素插入到指定位置，原位置及后续元素都顺序向后移动。
?
2、E remove(int index)：删除给定位置的元素，并将被删除的元素返回。
?
3、E get(int index)：获取集合中指定下标对应的元素，下标从0开始。
4、E set(int index, E element)：将给定的元素存入给定位置，并将原位置的元素返回。
2.2.3 【案例】ArrayList方法示例
编写代码，测试ArrayList的使用。代码示意如下：
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo1 {
public static void main(String[] args) {
// 使用泛型ArrayList集合
ArrayList<String> mylist = new ArrayList<>();
// 向集合中添加3个元素
mylist.add("one");
mylist.add("two");
mylist.add("three");
System.out.println("此列表元素包括："+mylist);
System.out.println("------");
// E get(int i) 返回集合中指定下标的元素
String s = mylist.get(2);
System.out.println("索引号为2的元素是："+s);
System.out.println("------");
// E set(int index,E e)将给定位置的元素替换成
// 新元素,并返回被替换的元素
String old = mylist.set(2, "3");
System.out.println("被替换的元素："+old);
System.out.println("此列表元素包括："+mylist);
System.out.println("------");
// void add(int index,E e)向指定位置插入元素
mylist.add(1,"2");
System.out.println(mylist);
System.out.println("------");
// E remove(int index)删除并返回指定位置的元素
// 删除索引号为1的元素
old = mylist.remove(1);
System.out.println(old);
System.out.println(mylist);
System.out.println("------");
// List取子集List subList(int start,int end)
// 包括0号元素，不包括2号元素
List<String> subList = mylist.subList(0, 2);
System.out.println("子集元素包括："+subList);
System.out.println("------");
// 使用foreach语句遍历
for (String e: mylist){
System.out.print(e+' ');
}
}
}2.2.4 【案例】ArrayList应用示例
案例背景：
1、在本地D:/data文件夹中存放了两个csv文件，分别是subject.csv文件和exam.csv文件，分别存储科目信息和考试信息，文件内容如下图所示。
?案例需求：
1、创建Subject类，用于封装科目信息。创建Exam类，用于封装考试信息。两个类的属性设计如下所示。
?2、使用IO流读取subject.csv文件，解析其中的数据，每行数据封装成一个Subject对象，存储到ArrayList<Subject>集合subjectList中。
3、使用IO流读取exam.csv文件，解析其中的数据，每行数据封装成一个Exam对象，存储到ArrayList<Exam>集合examList中。在Exam对象中需要根据subject_id列的值，关联对应的Subject对象。
4、从examList中筛选出考试时间在10点之后的数据，将考试信息输出到控制台。
输出结果如下图所示。
?
import java.io.BufferedReader;
import java.io.FileReader;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
public class ArrayListDemo2 {
public static void main(String[] args) {
String subjectPath = "d:/data/subject.csv";
String examPath = "d:/data/exam.csv";
ArrayList<Subject> subjects = readSubjects(subjectPath);
System.out.println(subjects); // 打印科目信息
ArrayList<Exam> exams = readExams(examPath, subjects);
System.out.println(exams); // 打印考试信息
// 筛选出考试时间在10点之后的考试信息
DateTimeFormatter formatter =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
for (Exam exam : exams) {
LocalDateTime ldt = LocalDateTime.parse(exam.getStartTime(),formatter);
if (ldt.getHour()>9){
System.out.println(exam);
}
}
}
/**
* 读取文件中的数据，每行生成一个考试对象，存储到集合中
* @param path
* @param subjects
* @return
*/
public static ArrayList<Exam> readExams(String path, ArrayList<Subject> subjects) {
List<String> lines = readLines(path);
ArrayList<Exam> exams = new ArrayList<>();
for (String line : lines) {
String[] arr = line.split(",");
Exam exam = new Exam();
exam.setId(Integer.parseInt(arr[0]));
exam.setName(arr[1]);
exam.setStartTime(arr[2]);
exam.setDuration(Integer.parseInt(arr[3]));
// 遍历科目数据，获取科目对象
for (Subject subject : subjects) {
if (subject.getId() .equals(Integer.parseInt(arr[4]))) {
exam.setSubject(subject);
break;
}
}
exams.add(exam);
}
return exams;
}
/**
* 读取文件中的数据，每行生成一个科目对象，存储到集合中
* @param path
* @return
*/
public static ArrayList<Subject> readSubjects(String path){
List<String> lines = readLines(path);
ArrayList<Subject> subjects = new ArrayList<>();
for(String line : lines){
String[] arr = line.split(",");
Subject subject = new Subject();
subject.setId(Integer.parseInt(arr[0]));
subject.setName(arr[1]);
subjects.add(subject);
}
return subjects;
}
/**
* 读取文件中的数据，每行生成一个字符串，存储到集合中
* @param path
* @return
*/
public static ArrayList<String> readLines(String path){
ArrayList<String> lines = new ArrayList<>();
try(
FileReader fr = new FileReader(path);
BufferedReader br = new BufferedReader(fr);
){
String line = br.readLine();
line = br.readLine(); // 跳过第一行
while(line != null){
lines.add(line);
line = br.readLine();
}
}catch (Exception e){
e.printStackTrace();
}
return lines;
}
}2.2.5 ArrayList的扩容机制
ArrayList的扩容机制是指在容量不足以容纳新元素时，自动增加ArrayList的容量，即ArrayList使用的内部数组的长度，以便能够容纳更多的元素。
ArrayList类中定义了一个变量elementData，代表实际存储数据的数组。ArrayList的容量，指的就是这个数组的容量。
1、初始容量
ArrayList中的初始容量分为2种情况：未指定初始长度和手动指定初始长度。
首先来看未指定初始长度的情况。
ArrayList类中定义了一个空的Object类型数组，如下所示。
在创建ArrayList对象时，如果没有指定初始容量，ArrayList会使用该数组作为内部数组，此时内部数组的长度为0。
?当第一次向该ArrayList对象中添加一个元素时，ArrayList会先初始化一个默认长度的内部数组，再将元素添加到该数组中。这个默认长度由ArrayList中的一个静态常量指定，如下所示。
因此，ArrayList的初始容量为0，在添加第一个元素时动态扩容为10。
接下来，我们来看手动指定初始长度的情况。
手动指定初始长度是指通过ArrayList的带参构造器ArrayList(int initialCapacity)来创建ArrayList对象。此时，ArrayList会使用传入的值作为新建的内部数组的长度，源码入下图所示。
?
因此，如果手动指定了长度，ArrayList的初始容量即为指定的长度。
2、容量增长
当添加元素导致ArrayList的大小超过当前容量时，ArrayList会自动进行容量增长。容量增长的策略是通过创建一个新的更大容量的数组，并将原有元素复制到新数组中。
当需要增加容量时，ArrayList会根据一定的增量大小（通常为当前容量的一半）计算新的容量。
新容量的计算公式为：newCapacity = oldCapacity + (oldCapacity >> 1)。
例如，一个已经添加了10个元素的ArrayList，在添加第11个元素时，容量会扩容到10 + (10 >>1) =15。
3、复制元素
在进行容量增长时，ArrayList会创建一个新的数组，并将原有的元素复制到新数组中。
复制元素的操作可能会导致一定的性能开销，特别是在ArrayList中存储大量元素时。例如，向ArrayList中依次添加128个元素，会导致ArrayList进行7次动态扩容。
因此，集合操作的一项重要的最佳实践是：当事先知道要存储的总元素数量时，应使用ArrayList的带参构造器来创建ArrayList，以减少动态扩容带来的性能开销。
2.2.6 ArrayList的缩容操作
与自动扩容机制不同，ArrayList并不会在删除元素时进行自动缩容操作。但是ArrayList提供了trimToSize方法，用于手动实现缩容的效果。
2.2.7 ArrayList与数组的区别
这是一道常见的面试题，可以从以下几个方面回答。
1、大小的固定性：数组一旦创建，大小是固定的，无法改变；ArrayList的大小是可变的，可以根据需要动态增长或缩小。
2、对象类型和原始类型：数组可以存储对象类型和原始类型的值，例如，int[]可以存储整数，String[]可以存储字符串；ArrayList只能存储对象类型，不能直接存储原始类型，需要使用对应的包装类。
3、功能和灵活性：数组的功能相对有限，仅提供了基本的操作，如访问和赋值；ArrayList提供了丰富的方法来插入、删除、替换和访问元素。
2.2.8 ArrayList与数组的转换
1、集合转为数组
使用 toArray() 方法将集合转换为数组，有两种形式：
- Object[] toArray()
- <T>T[] toArray(T[] a)
其中，第二种比较常用：可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致，返回值则是转换后的数组，该数组会保存集合中所有的元素。
2、数组转为集合
Arrays类的静态方法 asList() 可以将一个数组转换为对应的 List 集合：
static <T>List<T> asList<T… a>返回的 List 的集合元素类型由传入的数组的元素类型决定。
注意：对于返回的集合，不能对其增删元素，否则会抛出异常；并且对集合的元素进行修改会影响数组对应的元素。
2.2.9 【案例】ArrayList与数组的转换示例
请使用AI工具生成一个测试，并在开发工具中测试该示例，练习ArrayList和数组之间的转换。
2.3 LinkedList
2.3.1 LinkedList概述
LinkedList是另一个常用的List接口实现类，内部维护了一个双向链表。
LinkedList在常用API方面与ArrayList非常相似，只是在性能上有一定的差别，学习LinkedList的重点是掌握它内部的数据结构以及这种结构带来的优点和缺点。
LinkedList集合中的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。如下图所示：
?集合中有多个元素之间的关系如下图所示：
?当插入一个新元素时，只需要修改元素之间的这种引用关系，删除一个节点也是如此。如下图所示：
由图可以看出：LinkedList集合对于元素的增、删操作快捷方便。但是LinkedList集合不支持随机取值，每次都只能从一端或双向链表中的某节点开始遍历，直到找到查询的对象再返回，由于无法保存上一次的查询位置，因此实现查询操作的效率低下。
2.3.2 LinkedList的特点
LinkedList的主要特点如下：
1、链表结构：LinkedList使用双向链表的数据结构来存储和操作元素。
2、动态大小：LinkedList不需要指定初始大小，并且可以根据需要自动调整容量。
3、高效的插入和删除操作：由于LinkedList使用链表结构，插入和删除元素的性能相对较好。
4、不支持随机访问： LinkedList不支持通过索引直接访问元素，需要从头节点或尾节点开始遍历链表。
5、遍历操作：LinkedList实现了Iterable接口，因此可以使用迭代器（Iterator）或者增强型for循环来遍历链表中的元素。
2.3.3 【案例】LinkedList与ArrayList比较示例
编写代码，测试LinkedList与ArrayList两种集合，在头部插入、中部插入和尾部插入时的效率。代码示意如下：
import java.util.ArrayList;
import java.util.LinkedList;
public class ListPerformanceComparison {
public static void main(String[] args) {
int iterations = 100000; // 迭代次数
// 测试ArrayList
ArrayList<Integer> arrayList = new ArrayList<>();
long arrayListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
arrayList.add(0, i); // 头部插入
}
long arrayListEndTime = System.currentTimeMillis(); // 结束时间
long arrayListDuration = arrayListEndTime - arrayListStartTime; // 执行时间
// 测试LinkedList
LinkedList<Integer> linkedList = new LinkedList<>();
long linkedListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
linkedList.addFirst(i); // 头部插入
}
long linkedListEndTime = System.currentTimeMillis(); // 结束时间
long linkedListDuration = linkedListEndTime - linkedListStartTime; // 执行时间
System.out.println("ArrayList 头部插入耗时: " + arrayListDuration + " 毫秒");
System.out.println("LinkedList 头部插入耗时: " + linkedListDuration + " 毫秒");
// 清空列表
arrayList.clear();
linkedList.clear();
// 测试ArrayList
arrayListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
arrayList.add(i / 2, i); // 中部插入
}
arrayListEndTime = System.currentTimeMillis(); // 结束时间
arrayListDuration = arrayListEndTime - arrayListStartTime; // 执行时间
// 测试LinkedList
linkedListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
int index = linkedList.size() / 2;
linkedList.add(index, i); // 中部插入
}
linkedListEndTime = System.currentTimeMillis(); // 结束时间
linkedListDuration = linkedListEndTime - linkedListStartTime; // 执行时间
System.out.println("ArrayList 中部插入耗时: " + arrayListDuration + " 毫秒");
System.out.println("LinkedList 中部插入耗时: " + linkedListDuration + " 毫秒");
// 清空列表
arrayList.clear();
linkedList.clear();
// 测试ArrayList
arrayListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
arrayList.add(i); // 尾部插入
}
arrayListEndTime = System.currentTimeMillis(); // 结束时间
arrayListDuration = arrayListEndTime - arrayListStartTime; // 执行时间
// 测试LinkedList
linkedListStartTime = System.currentTimeMillis(); // 开始时间
for (int i = 0; i < iterations; i++) {
linkedList.add(i); // 尾部插入
}
linkedListEndTime = System.currentTimeMillis(); // 结束时间
linkedListDuration = linkedListEndTime - linkedListStartTime; // 执行时间
System.out.println("ArrayList 尾部插入耗时: " + arrayListDuration + " 毫秒");
System.out.println("LinkedList 尾部插入耗时: " + linkedListDuration + " 毫秒");
}
}2.3.4 ArrayList和LinkedList的区别
ArrayList和LinkedList都是List接口的实现类，用于存储单列数据。ArrayList和LinkedList在数据结构、随机访问性能、插入和删除操作性能等方面有所区别。
首先，ArrayList底层基于数组存储数据，可以看成是一个大小可变的数组。LinkedList底层基于双向链表存储数据。
ArrayList支持使用下标（索引）随机访问集合中的元素，随机访问的性能较好。LinkedList不能根据下标直接访问元素，需要从头部或尾部开始遍历链表，随机访问性能较差。
ArrayList在尾部进行插入和删除的性能较好，但在中间或头部进行插入和删除操作时，需要移动其他元素，性能较差。LinkedList在头尾进行插入和删除的性能较好。
注意：以上的对比都是在数据量很大或者操作很频繁的情况下的对比，如果数据和运算量很小，上述对比将失去意义。
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！