Java中List集合有哪些特性?(内含视频教程)
本文将为大家详细讲解Java中的List集合,这是我们进行开发时经常用到的知识点,也是大家在学习Java中很重要的一个知识点,更是我们在面试时有可能会问到的问题。
文章较长,干货满满,建议大家收藏慢慢学习。文末有本文重点总结,主页有全系列文章分享。技术类问题,欢迎大家和我们一起交流讨论!
前言
在上一篇文章中给大家介绍了Java里的集合,我们了解了集合的由来、特点,以及一些接口API等,但这些内容都偏重于理论。 那么从今天这篇文章开始,我们会从实战的角度来进行List集合的学习。可以说,List集合是开发时用的最多的一种集合,尤其是ArrayList更是被经常使用。
所以对今天的内容,希望大家要好好阅读和练习
全文大约 【5800】 字,不说废话,只讲可以让你学到技术、明白原理的纯干货!本文带有丰富的案例及配图视频,让你更好地理解和运用文中的技术概念,并可以给你带来具有足够启迪的思考...
一. List集合简介
1. 概述
List本身是一个接口,该接口继承自Collection接口,它有两个常用的实现子类ArrayList和LinkedList。从功能特性上来看,List是有序、可重复的单列集合,集合中的每个元素都有对应的顺序索引,我们可以通过该索引来访问指定位置上的集合元素。默认情况下,List会按元素的添加顺序给元素设置索引,第一个添加到List集合中的元素索引为0,第二个为1,后面依此类推。所以List的行为和数组几乎完全相同,它们都是有序的存储结构。另外List集合中允许有重复的元素,甚至可以有多个null值。
但是如果我们是使用数组来添加和删除元素,就会非常的不方便。比如从一个已有的数组{'A', 'B', 'C', 'D', 'E'}中删除索引为2的元素,这个“删除”操作实际上是把'C'后面的元素依次往前挪一个位置;而“添加”操作实际上是把指定位置以后的元素依次向后挪一个位置,腾出位置给新加入的元素。针对这两种操作,使用数组实现起来都会非常麻烦。所以在实际应用中,我们增删元素时,一般都是使用有序列表(如ArrayList),而不是使用数组。
2. 类关系
我们来看看List接口的类关系,如下图所示:
从这个类关系中我们可以看到,List接口继承了Collection接口,并且有ArrayList、LinkedList、Vector
等子类,其中Vector现在已经不太常用了,所以我们重点掌握ArrayList
和LinkedList
就行。
3. 常用API方法
在List接口中定义了子类的一些通用方法,如下所示:
- boolean add(E e) :在集合末尾添加一个数据元素;
- boolean add(int index, E e) :在集合的指定索引出添加一个数据元素;
- E remove(int index) :删除集合中指定索引的元素;
- boolean remove(Object e) :删除集合中的某个元素;
- E get(int index) :获取集合中指定索引出的元素;
- int size() :获取集合的大小(包含元素的个数)。
以上这些方法,就是我们在开发时比较常用的几个方法,一定要记住
4. List对象创建方式
List作为一个接口,我们通常不能直接new List来创建其对象,在Java中给我们提供了如下两种创建List对象的方式:
- 通过多态方式创建:new List的某个子类,比如new ArrayList()等;
- 通过List.of()方法创建:of()方法可以根据给定的数据元素快速创建出List对象,但该方法不接受null值,如果传入null会抛出NullPointerException异常。
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Demo01 {
public static void main(String[] args) {
//创建List对象方式一:
List<String> list1=new ArrayList<>();
List<String> list2=new LinkedList<>();
//创建List对象方式二:
List<Integer> list3 = List.of(1,3,5,7,9);
//该方式不能传入null参数,否则会产生NullPointerException异常
//List<Integer> list4 = List.of(1,3,5,7,9,null);
}
}
5. List集合遍历方式
很多时候,我们都会对集合进行遍历操作,也就是要把集合中的每个元素挨个的取出来,以下是几种常用的集合遍历方式:
- 普通for循环配合get(索引值)方法进行遍历: 这种遍历方式实现起来代码较为复杂,且get(int)取值方法只对ArrayList比较高效,但对LinkedList效率较低,索引越大时访问速度越慢。
- 增强for循环进行遍历: 我们也可以使用增强for循环进行遍历,该方式比普通for循环实现起来更为简洁。
- 使用Iterator迭代器进行集合遍历: 不同的List对象调用iterator()方法时,会返回不同实现的Iterator对象,该Iterator对象对集合总是具有最高的访问效率。
import java.util.Iterator;
import java.util.List;
public class Demo02 {
public static void main(String[] args) {
//List遍历方式一,普通for循环:
List<String> list = List.of("java", "大数据", "壹壹哥");
for(int i=0;i<list.size();i++) {
System.out.println("遍历方式一,值="+list.get(i));
}
//List遍历方式二,迭代器:
Iterator<String> it = list.iterator();
while(it.hasNext()){
//取出下一个值
String value = it.next();
System.out.println("遍历方式二,值="+value);
}
//List遍历方式三,增强for循环:内部会自动使用Iterator
for(String item:list) {
System.out.println("遍历方式三,item="+item);
}
}
}
上面提到的Iterator对象,有两个常用方法,如下所示:
boolean hasNext(): 该方法用于判断集合中是否还有下一个元素;
E next(): 该方法用于返回集合的下一个元素。
虽然使用Iterator遍历List集合的代码,看起来比使用索引较复杂,但Iterator遍历List集合的效率却是最高效的方式。
另外只要是实现了Iterable接口的集合类,我们都可以直接使用for each增强循环来遍历。在增强for循环中,Java编译器会自动把for each循环变成基于Iterator方式的遍历方式。
6. List与数组的转换方式
其实List与Array数组在很多地方都是比较相似的,比如都可以根据索引对数据元素进行遍历取值等操作。因为存在着这种相似之处,所以在List和数组之间是可以互相转换的,即List集合可以转成数组,数组也可以转成List集合。
6.1 List转数组
一般情况下,List转数组有如下几种方式:
- toArray() 方法:该方法会返回一个Object[]数组,但该方法会丢失类型信息,在实际开发时较少使用;
- toArray(T[])方法:传入一个与集合的数据元素类型相同的Array,List会自动把元素复制到传入的Array中;
- T[] toArray(IntFunction<T[]> generator) 方法:函数式写法,这是Java中的新特性,后面我们会单独讲解。大家可以持续关注
import java.util.List;
public class Demo03 {
public static void main(String[] args) {
List<String> list = List.of("java", "大数据", "壹壹哥");
// List转数组方式一:返回一个Object[]数组
Object[] array = list.toArray();
for (Object val : array) {
System.out.println("方式一,value="+val);
}
// List转数组方式二,给toArray(T[])传入与数组元素类型相同的Array,如果数组类型与集合数据元素类型不匹配则会产生如下异常:
// java.lang.ArrayStoreException: arraycopy: element type mismatch:
//can not cast one of the elements of java.lang.Object[] to the type of the destination array, java.lang.Integer
String[] array2 = list.toArray(new String[list.size()]);
for (String val : array2) {
System.out.println("方式二,value="+val);
}
// List转数组方式三:返回一个String[]数组
String[] array3 = list.toArray(String[]::new);
for (String val : array3) {
System.out.println("方式二,value="+val);
}
}
}
在本案例中,第一种实现方式是调用toArray()方法直接返回一个Object[]数组,但这种方法会丢失类型信息,所以开发是很少使用。
第二种方式要给toArray(T[])方法传入一个与集合数据元素类型相同的Array,List内部会自动把元素复制到传入的Array数组中。如果Array类型与集合的数据元素类型不匹配,就会产生”java.lang.ArrayStoreException: arraycopy: element type mismatch: can not cast one of the elements of java.lang.Object[] to the type of the destination array......“异常。
第三种方式是通过List接口定义的T[] toArray(IntFunction<T[]> generator)方法,这是一种函数式写法,以后再单独给大家讲解。可以持续关注我们哦
6.2 数组转List
反过来,数组也可以转为List集合,一般的方式如下:
- List.of(T...)方法:该方法会返回一个只读的List集合,如果我们对只读List调用add()、remove()方法会抛出UnsupportedOperationException异常。其中的T是泛型参数,代表要转成List集合的数组;
- Arrays.asList(T...) 方法:该方法也会返回一个List集合,但它返回的List不一定就是ArrayList或者LinkedList,因为List只是一个接口。
import java.util.Arrays;
import java.util.List;
public class Demo04 {
public static void main(String[] args) {
// 数组转List的方式一:List.of()返回一个只读的集合,不能进行add/remove等修改操作。
List<Integer> values = List.of(1,8,222,10,5);
for (Integer val : values) {
System.out.println("方式一,value="+val);
//该集合是一种只读的集合,不能在遍历时进行增删改等更新操作,只能进行读取操作,
//否则会产生java.lang.UnsupportedOperationException异常
//values.remove(0);
}
// 数组转List的方式二:Arrays.asList()返回一个只读的集合,不能进行add/remove等修改操作。
List<String> items = Arrays.asList("java","壹壹哥","元宇宙");
for (String item : items) {
System.out.println("方式二,value="+item);
//不可以进行增删改操作
//items.add("sss");
//items.remove(0);
}
}
}
在本案例中,无论我们是通过List.of()方法,还是通过Arrays.asList()方法,都只会返回一个只读的集合。这种集合在遍历时不能进行增删改等更新操作,只能进行读取操作,否则会产生java.lang.UnsupportedOperationException异常。
二. ArrayList集合
1. 简介
ArrayList是一个数组队列,位于java.util包中,它继承自AbstractList,并实现了List接口。其底层是一个可以动态修改的数组,该数组与普通数组的区别,在于它没有固定的大小限制,我们可以对其动态地进行元素的添加或删除
存储在集合内的数据被称为”元素“,我们可以利用索引来访问集合中的每个元素。为了方便我们操作这些元素,ArrayList给我们提供了相关的添加、删除、修改、遍历等功能。
因为ArrayList的底层是一个动态数组,所以该集合适合对元素进行快速的随机访问(遍历查询),另外尾部成员的增加和删除操作速度也较快,但是其他位置上元素的插入与删除速度相对较慢。基于这种特性,所以ArrayList具有查询快,增删慢的特点。
2. 常用方法
ArrayList给我们提供了如下这些方法,我们可以先来了解一下:
方法 | 描述 |
---|---|
add() | 将数据元素插入到ArrayList的指定位置上 |
addAll() | 将一个新集合中的所有元素添加到ArrayList中 |
clear() | 删除ArrayList中所有的元素 |
contains() | 判断元素是否在ArrayList中 |
get() | 通过索引值获取ArrayList中的元素 |
indexOf() | 返回ArrayList中某个元素的索引值 |
removeAll() | 删除ArrayList中指定集合的所有元素 |
remove() | 删除ArrayList里的单个元素 |
size() | 返回ArrayList的元素数量 |
isEmpty() | 判断ArrayList是否为空 |
subList() | 截取ArrayList的部分元素 |
set() | 替换ArrayList中指定索引的元素 |
sort() | 对ArrayList的数据元素进行排序 |
toArray() | 将ArrayList转换为数组 |
toString() | 将ArrayList转换为字符串 |
ensureCapacity() | 设置指定容量大小的ArrayList |
lastIndexOf() | 返回指定元素在ArrayList中最后一次出现的位置 |
retainAll() | 保留指定集合中的数据元素 |
containsAll() | 查看ArrayList是否包含了指定集合的所有元素 |
trimToSize() | 将ArrayList的容量调整为数组的元素个数 |
removeRange() | 删除ArrayList中指定索引间存在的元素 |
replaceAll() | 用给定的数据元素替换掉指定数组中每个元素 |
removeIf() | 删除所有满足特定条件的ArrayList元素 |
forEach() | 遍历ArrayList中每个元素并执行特定操作 |
接下来我们就挑选几个常用的方法,通过几个案例来给大家讲解一下ArrayList
的用法。
3. 添加元素
ArrayList给我们提供了多个与添加相关的方法,比如add()和addAll()方法,可以将元素添加到集合中。另外如果我们要计算ArrayList中元素的数量,可以使用size()方法。
import java.util.ArrayList;
public class Demo05 {
public static void main(String[] args) {
//创建ArrayList集合,<String>中的是泛型,后面我们会专门讲解泛型
ArrayList<String> names = new ArrayList<String>();
//一个一个地添加元素
names.add("一一哥");
names.add("java");
names.add("数学");
//遍历集合
for (String name : names) {
System.out.println("name="+name+",size="+names.size());
}
ArrayList<String> names2 = new ArrayList<String>();
names2.add("壹壹哥");
//在A集合中追加B集合
names2.addAll(names);
//遍历集合
for (String name : names2) {
System.out.println("name="+name);
}
}
}
在上面的代码中,
4. 遍历元素
我们对ArrayList中元素进行遍历的方式,其实与List的遍历是一样的,我们可以使用普通for循环、增强for循环、Iterator迭代器等方式对集合进行遍历,这里我们就不再单独展示其用法了。
5. 修改元素
我们使用add()方法将元素添加到集合中之后,如果想对集合中的元素进行修改,可以使用set()方法。
import java.util.ArrayList;
public class Demo06 {
public static void main(String[] args) {
//创建ArrayList集合,<String>中的是泛型,后面我们会专门讲解泛型
ArrayList<String> names = new ArrayList<String>();
//一个一个地添加元素
names.add("一一哥");
names.add("java");
names.add("数学");
//修改集合中的元素:第一个参数是集合中的索引,第二个是要修改的值
names.set(1, "Android");
names.set(2, "iOS");
//遍历集合
for (String name : names) {
System.out.println("name="+name);
}
}
}
6. 删除元素
如果我们要删除ArrayList中的元素,可以使用remove()、removeAll()
等方法。
import java.util.ArrayList;
public class Demo07 {
public static void main(String[] args) {
//创建ArrayList集合,<String>中的是泛型,后面我们会专门讲解泛型
ArrayList<String> names = new ArrayList<String>();
//一个一个地添加元素
names.add("一一哥");
names.add("java");
names.add("数学");
//删除集合中指定位置上的某个元素
names.remove(0);
//删除集合中的某个指定元素
names.remove("java");
//遍历集合
for (String name : names) {
System.out.println("name="+name);
}
ArrayList<String> names2 = new ArrayList<String>();
names2.add("语文");
names2.add("英语");
names2.add("数学");
//删除本集合中的另一个集合
names2.removeAll(names);
//遍历集合
for (String name : names2) {
System.out.println("name2="+name);
}
}
}
7. 集合排序
我们可以使用Collections.sort()方法对集合进行升序排列。
import java.util.ArrayList;
import java.util.Collections;
public class Demo08 {
public static void main(String[] args) {
//创建ArrayList集合
ArrayList<Integer> nums = new ArrayList<>();
//一个一个地添加元素
nums.add(100);
nums.add(85);
nums.add(120);
nums.add(55);
//对集合进行排序,默认是升序排列
Collections.sort(nums);
//遍历集合
for (Integer num : nums) {
System.out.println("num="+num);
}
}
}
8. 配套视频
本节内容配套视频链接如下:戳链接即可查看
三. LinkedList集合
1. 简介
LinkedList
采用链表结构来保存数据,所以是一种链表集合,类似于ArrayList,也是List的一个子类,位于java.util包中。它的底层是基于线性链表这种常见的数据结构,但并没有按线性的顺序存储数据,而是在每个节点中都存储了下一个节点的地址。
LinkedList的优点是便于向集合中插入或删除元素,尤其是需要频繁地向集合中插入和删除元素时,使用LinkedList类比ArrayList的效率更高。但LinkedList随机访问元素的速度则相对较慢,即检索集合中特定索引位置上的元素速度较慢。
2. LinkedList类关系
LinkedList
直接继承自AbstractSequentialList
,并实现了List、Deque、Cloneable、Serializable等多个接口。通过实现List接口,具备了列表操作的能力;通过实现Cloneable接口,具备了克隆的能力;通过实现Queue和Deque接口,可以作为队列使用;通过实现Serializable接口,可以具备序列化能力。LinkedList类结构关系如下图所示:
3. LinkedList与ArrayList对比
与ArrayList相比,LinkedList进行添加和删除的操作效率更高,但查找和修改的操作效率较低。基于这种特性,我们可以在以下情况中使用ArrayList:
- 需要经常访问获取列表中的某个元素;
- 只需要在列表的 末尾 进行添加和删除某个元素。
当遇到如下情况时,可以考虑使用LinkedList:
- 需要经常通过 循环迭代来访问 列表中的某些元素;
- 需要经常在列表的 开头、中间、末尾 等位置进行元素的添加和删除操作。
4. 常用方法
LinkedList
中的很多方法其实都来自于List接口,所以它的很多方法与ArrayList是一样的。但由于其自身特点,也具有一些特有的常用方法,这里只列出LinkedList
特有的常用方法,如下表所示:
方法 | 描述 |
---|---|
public void addFirst(E e) | 将元素添加到集合的头部。 |
public void addLast(E e) | 将元素添加到集合的尾部。 |
public boolean offer(E e) | 向链表的末尾添加元素,成功为true,失败为false。 |
public boolean offerFirst(E e) | 在链表头部插入元素,成功为true,失败为false。 |
public boolean offerLast(E e) | 在链表尾部插入元素,成功为true,失败为false。 |
public void clear() | 清空链表。 |
public E removeFirst() | 删除并返回链表的第一个元素。 |
public E removeLast() | 删除并返回链表的最后一个元素。 |
public boolean remove(Object o) | 删除某一元素,成功为true,失败为false。 |
public E remove(int index) | 删除指定位置的元素。 |
public E poll() | 删除并返回第一个元素。 |
public E remove() | 删除并返回第一个元素。 |
public E getFirst() | 返回第一个元素。 |
public E getLast() | 返回最后一个元素。 |
public int lastIndexOf(Object o) | 查找指定元素最后一次出现的索引。 |
public E peek() | 返回第一个元素。 |
public E element() | 返回第一个元素。 |
public E peekFirst() | 返回头部元素。 |
public E peekLast() | 返回尾部元素。 |
public Iterator descendingIterator() | 返回倒序迭代器。 |
public ListIterator listIterator(int index) | 返回从指定位置开始到末尾的迭代器。 |
对这些方法进行基本的了解之后,接下来我们选择几个核心方法来来看看具体该怎么使用。
5. 添加/删除元素
我们可以通过addFirst()和addLast()
方法,分别在链表的开头和结尾添加一个元素。当我们要频繁地在一个列表的开头和结尾进行元素添加、删除时,使用````LinkedList要比
ArrayList```的效率更高。
import java.util.LinkedList;
public class Demo09 {
public static void main(String[] args) {
// 创建LinkedList集合
LinkedList<String> names = new LinkedList<String>();
// 一个一个地添加元素
names.add("一一哥");
names.add("java");
names.add("数学");
//在链表的开头添加元素
names.addFirst("壹壹哥");
//在链表的结尾添加元素
names.addLast("历史");
// 遍历集合
for (String name : names) {
System.out.println("name=" + name);
}
//移除链表开头的元素
names.removeFirst();
//移除链表结尾的元素
names.removeLast();
}
}
6. 迭代获取元素
我们可以通过getFirst()、getLast()
等方法获取到集合中的第一个、最后一个元素。
import java.util.LinkedList;
public class Demo10 {
public static void main(String[] args) {
// 创建LinkedList集合
LinkedList<String> names = new LinkedList<String>();
// 一个一个地添加元素
names.add("一一哥");
names.add("java");
names.add("数学");
System.out.println("first=" + names.getFirst());
System.out.println("last=" + names.getLast());
// 迭代遍历集合
for (String name : names) {
System.out.println("name=" + name);
}
}
}
7. 配套视频
本节内容配套视频链接如下:戳链接直达视频教程
四. 结语
至此我们就把List集合给大家讲解完毕了,最后我们再来看看本文的重点吧:
List是按索引顺序访问的、长度可变的有序列表;
一般开发时,ArrayList比LinkedList的使用更频繁;
List和Array可以相互转换;
集合遍历时有多种方式,增强for循环和Iterator迭代器的效率更高;
ArrayList与LinkedList都是List接口的实现类,都实现了List中所有未实现的方法,但实现的方式有所不同;
ArrayList底层的数据结构基于动态数组,访问元素速度快于LinkedList,在快速访问数据时ArrayList的执行效率比较高;
LinkedList底层的数据结构基于链表,占用的内存空间较大,但批量插入或删除数据时快于ArrayList。当频繁向集合中插入和删除元素时,使用LinkedList比ArrayList的效率更高。
以上就是本文的全部内容啦,大家有技术类问题,欢迎和我们一起交流讨论~
更多技术类干货,关注我!
我是专门分享技术干货的分享君!