极客教程Java中的List接口及示例
Java中的List接口提供了存储有序集合的方法。它是Collection接口的一个子接口，是一个有序的对象集合，其中可以存储重复的值。由于List保留插入顺序，因此允许定位访问和插入元素。
List接口位于java.util包中，并继承了Collection接口。它是ListIterator接口的工厂。通过ListIterator，我们可以正向和反向迭代列表。List接口的实现类有ArrayList、LinkedList、Stack和Vector。ArrayList和LinkedList在Java编程中广泛使用。自Java 5以后，Vector类已被弃用。
声明： List接口的声明方式是：
public interface List<E> extends Collection<E> ;
让我们详细介绍如何在List类中创建对象或实例。 由于List是一个接口，所以不能创建List类型的对象。我们总是需要一个实现此List接口的类来创建对象。此外，在Java 1.5引入泛型之后，可以限制可以存储在List中的对象的类型。与其他由用户定义的“接口”由用户定义的“类”实现的多个其他自定义“接口”一样，List是一个由预定义在java.util包中的ArrayList类实现的“接口”。
语法： 这种类型的安全列表可以定义为：
List<Obj> list = new ArrayList<Obj> ();
注意： Obj是要存储在List中的对象的类型
示例：
// Java program to Demonstrate List Interface
// Importing all utility classes
import java.util.*;
// Main class
// ListDemo class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an object of List interface
// implemented by the ArrayList class
List<Integer> l1 = new ArrayList<Integer>();
// Adding elements to object of List interface
// Custom inputs
l1.add(0, 1);
l1.add(1, 2);
// Print the elements inside the object
System.out.println(l1);
// Now creating another object of the List
// interface implemented ArrayList class
// Declaring object of integer type
List<Integer> l2 = new ArrayList<Integer>();
// Again adding elements to object of List interface
// Custom inputs
l2.add(1);
l2.add(2);
l2.add(3);
// Will add list l2 from 1 index
l1.addAll(1, l2);
System.out.println(l1);
// Removes element from index 1
l1.remove(1);
// Printing the updated List 1
System.out.println(l1);
// Prints element at index 3 in list 1
// using get() method
System.out.println(l1.get(3));
// Replace 0th element with 5
// in List 1
l1.set(0, 5);
// Again printing the updated List 1
System.out.println(l1);
}
}
输出
[1, 2]
[1, 1, 2, 3, 2]
[1, 2, 3, 2]
2
[5, 2, 3, 2]
现在让我们使用List接口执行各种操作，以更好地理解它。我们将讨论以下列出的操作，然后通过简洁的Java代码实现。
List接口中的操作
由于List是一个接口，它只能与实现该接口的类一起使用。现在，让我们看看如何在List上执行一些常用操作。
- 操作1： 使用add()方法将元素添加到List类中
- 操作2： 使用set()方法更新List类中的元素
- 操作3： 使用indexOf()、lastIndexOf方法搜索元素
- 操作4： 使用remove()方法删除元素
- 操作5： 使用get()方法访问List类中的元素
- 操作6： 使用contains()方法检查List类中是否存在元素
现在让我们逐个讨论这些操作，并在代码中实现它们以更好地掌握它。
操作1： 使用 add()方法 将元素添加到List类中
为了将元素添加到列表中，我们可以使用 add()方法 。该方法会因不同的参数而重载以执行多个操作。
参数： 它有2个参数，即：
- add(Object)： 该方法用于在List的末尾添加元素。
- add(int index, Object)： 该方法用于将元素添加到List的特定索引处。
示例：
//Java Program to Add Elements to a List
//导入所有实用程序类
import java.util.*;
//主类
class GFG {
//主驱动程序方法
public static void main(String args[])
{
//创建List接口的对象，由ArrayList类实现
List<String> al = new ArrayList<>();
//向List接口对象添加元素
al.add("Geeks");
al.add("Geeks");
al.add(1, "For");
//打印List接口对象中的所有元素
System.out.println(al);
}
}
输出结果：
[Geeks, For, Geeks]
操作2： 更新元素
在添加元素后，如果我们想要更改元素，则可以使用 set()方法 进行更改。由于List是有索引的，我们希望更改的元素由该元素的索引引用。因此，该方法接受一个索引和需要插入到该索引处的更新元素。
示例：
//Java Program to Update Elements in a List
//导入实用程序类
import java.util.*;
//主类
class GFG {
//主驱动程序方法
public static void main(String args[])
{
//创建List接口的对象
List<String> al = new ArrayList<>();
//向List类的对象添加元素
al.add("Geeks");
al.add("Geeks");
al.add(1, "Geeks");
//显示List中的初始元素
System.out.println("Initial ArrayList " + al);
//使用set()方法在第一个索引处设置（更新）元素
al.set(1, "For");
//打印并显示更新的List
System.out.println("Updated ArrayList " + al);
}
}
输出结果：
Initial ArrayList [Geeks, Geeks, Geeks]
Updated ArrayList [Geeks, For, Geeks]
操作3： 查找元素
在Java编程中，查找List接口中的元素是一个常见的操作。List接口提供了多种搜索元素的方法，例如 indexOf() 和 lastIndexOf() 方法。
indexOf()方法返回列表中指定元素的第一个出现位置的索引，而lastIndexOf()方法返回指定元素的最后一个出现位置的索引。
参数：
- indexOf(element): 返回列表中指定元素的第一个出现位置的索引，如果元素未找到，则返回-1
- lastIndexOf(element): 返回列表中指定元素的最后一个出现位置的索引，如果元素未找到，则返回-1
示例:
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// 创建一个整数列表
List numbers = new ArrayList<>();
// 向列表中添加一些整数
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2);
// 使用indexOf()在列表中查找元素的第一次出现
int index = numbers.indexOf(2);
System.out.println("2 的第一次出现是在索引 " + index);
// 使用lastIndexOf()在列表中查找元素的最后一次出现
int lastIndex = numbers.lastIndexOf(2);
System.out.println("2 的最后一次出现是在索引 " + lastIndex);
}
}
输出
2 的第一次出现是在索引 1
2 的最后一次出现是在索引 3
操作4： 删除元素
为了从列表中删除一个元素，可以使用remove()方法。该方法被重载以执行基于不同参数的多个操作。它们是：
参数：
- remove(Object): 此方法用于删除列表中的一个对象。如果有多个这样的对象，则删除对象的第一次出现。
- remove(int index): 由于List是有索引的，因此此方法接受一个整数值，该值仅删除列表中在该特定索引处的元素。删除元素后，所有元素移动到左侧以填充空间，并且对象的索引已更新。
示例:
// Java程序移除列表中的元素
// 导入java.util包中的List和ArrayList类
import java.util.ArrayList;
import java.util.List;
// 主类
class GFG {
// 主方法驱动程序
public static void main(String args[])
{
// 创建List类对象
List<String> al = new ArrayList<>();
// 添加元素到对象中
// 自定义输入
al.add("Geeks");
al.add("Geeks");
// 在1号索引添加For
al.add(1, "For");
// 打印初始ArrayList
System.out.println("Initial ArrayList " + al);
// 现在移除上面列表中的索引为1的元素
al.remove(1);
// 移除元素后，打印列表
System.out.println("After the Index Removal " + al);
// 现在从更新的列表上移除当前对象
al.remove("Geeks");
// 最终打印更新的列表
System.out.println("After the Object Removal "+ al);
}
}
输出
Initial ArrayList [Geeks, For, Geeks]
After the Index Removal [Geeks, Geeks]
After the Object Removal [Geeks]
操作5： 访问元素
为了访问列表中的元素，我们可以使用 get() 方法，该方法返回指定索引处的元素。
参数：
get(int index)：该方法返回列表中指定索引处的元素。
示例：
// Java程序访问列表元素
// 导入所有实用程序类
import java.util.*;
// 主类
class GFG {
// 主方法驱动程序
public static void main(String args[])
{
// 创建一个List接口的对象，
// 由ArrayList类实现
List<String> al = new ArrayList<>();
// 将元素添加到List接口对象中
al.add("Geeks");
al.add("For");
al.add("Geeks");
// 使用get() 方法访问元素
String first = al.get(0);
String second = al.get(1);
String third = al.get(2);
// 打印List接口对象中的所有元素
System.out.println(first);
System.out.println(second);
System.out.println(third);
System.out.println(al);
}
}
输出
Geeks
For
Geeks
[Geeks, For, Geeks]
操作6： 检查列表中是否存在元素
为了检查列表中是否存在元素，我们可以使用 contains() 方法。该方法如果指定的元素存在于列表中，则返回true，否则返回false。
参数：
contains(Object)：该方法接受一个参数，要检查的对象是否存在于列表中。
示例：
// Java程序检查一个元素是否存在于列表中
// 导入所有的公用类
import java.util.*;
// 主类
class GFG {
// 主驱动方法
public static void main(String args[])
{
// 创建一个 List 接口的对象，
// 由 ArrayList 类实现
List<String> al = new ArrayList<>();
// 向 List 接口的对象中添加元素
al.add("Geeks");
al.add("For");
al.add("Geeks");
// 使用 contains() 方法检查元素是否存在
boolean isPresent = al.contains("Geeks");
// 打印结果
System.out.println("在列表中是否存在 Geeks? " + isPresent);
}
}
输出
在列表中是否存在 Geeks? true
迭代列表
到目前为止，我们的输入规模非常小，我们对每个实体都手动操作。现在，让我们讨论各种方法，通过这些方法，我们可以迭代列表以使它们适用于更大的样本集。
方法: 有多种迭代 List 的方法。最著名的方式是使用基本的 for 循环与 get() 方法结合使用来获取特定索引处的元素以及高级 for 循环。
示例:
// Java程序迭代 ArrayList 中的元素
// 导入 java 的公用类
import java.util.*;
// 主类
public class GFG {
// 主驱动方法
public static void main(String args[])
{
// 创建一个空的 string 类型的 ArrayList 对象
List<String> al = new ArrayList<>();
// 向上述 ArrayList 对象中添加元素
al.add("Geeks");
al.add("Geeks");
// 在列表对象中指定位置添加元素
al.add(1, "For");
// 使用 for 循环进行迭代
for (int i = 0; i < al.size(); i++) {
// 使用 get() 方法访问特定元素
System.out.print(al.get(i) + " ");
}
// 为了更好的可读性换行
System.out.println();
// 使用 for-each 循环进行迭代
for (String str : al)
// 打印所有元素
// 在对象内
System.out.print(str + " ");
}
}
输出
Geeks For Geeks
Geeks For Geeks
List 接口的方法
由于不同类型的列表背后的主要概念相同，因此 list 接口包含以下方法:
| 方法 | 描述 |
|---|---|
| add(int index, element) | 此方法用于将元素添加到列表中的特定索引处。当传递单个参数时，它只是将元素添加到列表的末尾。 |
| addAll(int index, Collection collection) | 此方法用于将给定集合中的所有元素添加到列表中。当传递单个参数时，它会将给定集合的所有元素添加到列表的末尾。 |
| size() | 此方法用于返回列表的大小。 |
| clear() | 此方法用于删除列表中的所有元素。但是，列表的引用仍被保存。 |
| remove(int index) | 此方法从指定索引处移除一个元素。它将随后的元素（如果有）向左移动，并将它们的索引减少1。 |
| remove(element) | 此方法用于删除列表中给定元素的第一个实例。 |
| get(int index) | 此方法返回指定索引处的元素。 |
| set(int index, element) | 此方法使用新元素替换给定索引处的元素。此函数返回刚刚被新元素替换的元素。 |
| indexOf(element) | 此方法返回给定元素的第一个实例或 -1 如果元素不存在于列表中。 |
| lastIndexOf(element) | 此方法返回给定元素的最后一个实例或 -1 如果元素不存在于列表中。 |
| equals(element) | 此方法用于将给定元素与列表中的元素进行比较。 |
| hashCode() | 此方法用于返回给定列表的哈希码值。 |
| isEmpty() | 此方法用于检查列表是否为空。如果列表为空，则返回true，否则返回false。 |
| contains(element) | 此方法用于检查列表是否包含给定元素。如果列表包含元素，则返回true。 |
| containsAll(Collection collection) | 此方法用于检查列表是否包含所有元素的集合。 |
| sort(Comparator comp) | 此方法用于根据给定的comparator对列表的元素进行排序。 |
Java List vs Set
List接口和Set接口都继承了Collection接口。但是，它们之间存在一些差异。
| 列表 | 集合 |
|---|---|
| 列表是有顺序的序列。 | 集合是无序的序列。 |
| 列表中允许包含重复的元素 | 集合中不允许包含重复的元素。 |
| 可以通过它们的位置来访问元素。 | 不允许通过位置来访问元素。 |
| 可以存储多个空元素。 | 空元素只能存储一次。 |
| 列表的实现包括ArrayList、LinkedList、Vector和Stack | 集合的实现包括HashSet和LinkedHashSet。 |
与列表接口相关的类
接下来让我们讨论实现列表接口的类，为了更好地理解列表接口，请首先参考下面的图示表示，它如下所示：
AbstractList、CopyOnWriteArrayList和AbstractSequentialList是实现列表接口的类。每个类中都实现了不同的功能，具体情况如下：
- AbstractList： 这个类用来实现一个不可修改的列表，只需要扩展AbstractList类并实现get()和size()方法即可。
- CopyOnWriteArrayList： 这个类实现了列表接口。它是ArrayList的增强版本，在该类中所有修改（添加、设置、删除等操作）都是通过新复制一个列表来实现的。
- AbstractSequentialList： 这个类实现了Collection接口和AbstractCollection类。这个类用来实现一个不可修改的列表，只需要扩展AbstractList类并实现get()和size()方法即可。
我们将以此方式进行操作。
- ArrayList
- Vector
- Stack
- LinkedList
让我们按顺序逐个讨论它们，并实现相同的来理解具有列表接口的类的工作原理。
Class 1: ArrayList
ArrayList 类是集合框架中的一个类，它为我们提供了Java动态数组。虽然它可能比标准的数组慢，但在数组需要进行大量操作的程序中可以很有帮助。让我们看看如何使用这个类创建一个列表对象。
举个例子：
// Java program to demonstrate the
// creation of list object using the
// ArrayList class
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
// Size of ArrayList
int n = 5;
// Declaring the List with initial size n
List<Integer> arrli
= new ArrayList<Integer>(n);
// Appending the new elements
// at the end of the list
for (int i = 1; i <= n; i++)
arrli.add(i);
// Printing elements
System.out.println(arrli);
// Remove element at index 3
arrli.remove(3);
// Displaying the list after deletion
System.out.println(arrli);
// Printing elements one by one
for (int i = 0; i < arrli.size(); i++)
System.out.print(arrli.get(i) + " ");
}
}
输出结果：
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
类 2: Vector
Vector是一个类，实现了集合框架中的可增长对象数组。Vector实现了动态数组，也就是说它可以根据需要增长或缩小。像数组一样，它包含可以使用整数索引访问的组件。向量基本上属于遗留类，但现在它与集合完全兼容。让我们看看如何使用这个类创建一个列表对象。
示例:
// Java程序来演示
// 使用Vector类创建列表对象
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
// 向量的大小
int n = 5;
// 使用初始大小n声明列表
List v = new Vector(n);
// 在列表末尾添加新元素
for (int i = 1; i <= n; i++)
v.add(i);
// 打印元素
System.out.println(v);
// 删除索引为3的元素
v.remove(3);
// 删除后显示列表
System.out.println(v);
// 逐个打印元素
for (int i = 0; i < v.size(); i++)
System.out.print(v.get(i) + " ");
}
}
输出
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
类 3: Stack
Stack是一个类，它在集合框架中实现了并扩展了向量类模型，实现了栈数据结构。该类基于后进先出的基本原则。除了基本的推和弹出操作，该类还提供了三个函数empty、search和peek。让我们看看如何使用这个类创建一个列表对象。
示例:
// Java程序来演示
// 使用Stack类创建列表对象
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
// 栈的大小
int n = 5;
// 声明列表
List s = new Stack();
// 在列表末尾添加新元素
for (int i = 1; i <= n; i++)
s.add(i);
// 打印元素
System.out.println(s);
// 删除索引为3的元素
s.remove(3);
// 删除后显示列表
System.out.println(s);
// 逐个打印元素
for (int i = 0; i < s.size(); i++)
System.out.print(s.get(i) + " ");
}
}
输出
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5
类 4: LinkedList
LinkedList是一个类，在集合框架中实现了链表数据结构。它是一种线性数据结构，其中元素不存储在连续的位置上，每个元素都是一个具有数据部分和地址部分的单独对象。这些元素使用指针和地址链接。每个元素称为节点。由于其动态性和插入和删除的易于度，它们比数组更受欢迎。让我们看看如何使用这个类创建一个列表对象。
示例:
// Java program to demonstrate the
// creation of list object using the
// LinkedList class
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
// Size of the LinkedList
int n = 5;
// Declaring the List with initial size n
List<Integer> ll = new LinkedList<Integer>();
// Appending the new elements
// at the end of the list
for (int i = 1; i <= n; i++)
ll.add(i);
// Printing elements
System.out.println(ll);
// Remove element at index 3
ll.remove(3);
// Displaying the list after deletion
System.out.println(ll);
// Printing elements one by one
for (int i = 0; i < ll.size(); i++)
System.out.print(ll.get(i) + " ");
}
}
输出
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5