首页 > 代码库 > Java集合框架之List接口

Java集合框架之List接口

2024-08-29 00:22:18   216人阅读

在上一篇Java集合框架之Collection接口中我们知道List接口是Collection接口的子接口，List接口对Collection进行了简单的扩充，List接口中的元素的特点为有序，可重复，允许null值，因为List继承了Collection接口，所以继承自Collection接口中的方法不再赘述，从List接口中的方法来看，List接口主要是增加了面向位置的操作，允许在指定位置上对集合中的元素进行操作，同时增加了一个能够双向遍历线性表的新列表迭代器ListIterator。下面介绍List接口中的方法

1、添加

void add(int index,E element)：在指定位置添加元素

boolean addAll(int index,Collection<? extends E> c)，在指定的位置添加一个集合的元素

示例代码

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo1 {
 7     public static void main(String[] args) {
 8         List list1 = new ArrayList();
 9         list1.add("红楼梦");
10         list1.add("三国演义");
11         list1.add("三国演义");
12         list1.add(null);
13         System.out.println("集合的长度：" + list1.size());
14 
15         list1.add(1, "平凡的世界");
16         System.out.println(list1);
17 
18         List list2 = new ArrayList();
19         list2.add("西游记");
20         list2.add("水浒传");
21         list1.add(1, list2);
22         System.out.println(list1);
23     }
24 }

输出结果

集合的长度：4
[红楼梦, 平凡的世界, 三国演义, 三国演义, null]
[红楼梦, [西游记, 水浒传], 平凡的世界, 三国演义, 三国演义, null]

可以看到List中有重复的元素以及null元素，如果指定的位置超过了集合的长度，则会报IndexOutOfBoundsException异常，如下

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo1 {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9         list.add("红楼梦");
10         list.add("三国演义");
11         list.add("西游记");
12         list.add("水浒传");
13         System.out.println("集合的长度：" + list.size());
14 
15         list.add(5, "平凡的世界"); // 超过了集合的最大长度
16         System.out.println(list);
17     }
18 }

控制台输出结果

集合的长度：4
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 5, Size: 4
    at java.util.ArrayList.rangeCheckForAdd(Unknown Source)
    at java.util.ArrayList.add(Unknown Source)
    at list.ListDemo1.main(ListDemo1.java:15)

以下讲述的方法中，凡是涉及到位置的方法，如果指定的位置超过了集合的最大长度，则同样报IndexOutOfBoundsException异常。

2、获取

E get(int index)：返回指定位置的元素

int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1

int lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

List<E> subList(int fromIndex,int toIndex)：返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空）

示例代码

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo2 {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9         list.add("红楼梦");
10         list.add("三国演义");
11         list.add("西游记");
12         list.add("水浒传");
13         list.add("红楼梦");
14 
15         Object object = list.get(0);
16         System.out.println(object);
17 
18         int index = list.indexOf("红楼梦");
19         System.out.println("第一次出现红楼梦的索引：" + index);
20 
21         index = list.indexOf("平凡的世界");
22         System.out.println("第一次出现平凡的世界的索引：" + index);
23 
24         index = list.lastIndexOf("红楼梦");
25         System.out.println("最后一次出现红楼梦的索引：" + index);
26 
27         index = list.lastIndexOf("平凡的世界");
28         System.out.println("最后一次出现平凡的世界的索引：" + index);
29 
30         list = list.subList(1, 3); // 不包括3位置的元素
31         System.out.println(list);
32     }
33 }

输出结果

红楼梦
第一次出现红楼梦的索引：0
第一次出现平凡的世界的索引：-1
最后一次出现红楼梦的索引：4
最后一次出现平凡的世界的索引：-1
[三国演义, 西游记]

3、删除

E remove(int index)：移除列表中指定位置的元素（可选操作）。将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。

示例代码

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo3 {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9         list.add("红楼梦");
10         list.add("三国演义");
11         list.add("西游记");
12         list.add("水浒传");
13         
14         int index = list.indexOf("西游记");
15         System.out.println("西游记原来的索引：" + index);
16         
17         Object object = list.remove(1);
18         System.out.println("删除的元素: " + object);
19         
20         index = list.indexOf("西游记");
21         System.out.println("移除元素之后西游记的索引：" + index);
22         
23         System.out.println(list);
24     }
25 }

输出结果

西游记原来的索引：2
删除的元素: 三国演义
移除元素之后西游记的索引：1
[红楼梦, 西游记, 水浒传]

4、赋值

E set(int index,E element)：用指定元素替换列表中指定位置的元素（可选操作）。

代码示例

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo4 {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9         list.add("红楼梦");
10         list.add("三国演义");
11         list.add("西游记");
12         list.add("水浒传");
13         list.set(0, "平凡的世界");
14         System.out.println(list);
15     }
16 }

输出结果

[平凡的世界, 三国演义, 西游记, 水浒传]

5、遍历

ListIterator<E> listIterator()：返回此列表元素的列表迭代器（按适当顺序）。

ListIterator是一个接口，继承自Iterator接口，除了拥有Iterator接口中的方法之外，还拥有一些自己特有的方法

boolean hasPrevious()：逆向遍历列表，如果仍有元素可以迭代，则返回 true。

E previous()：返回迭代的上一个元素，并移动到上一个位置。

虽然ListIterator可以实现集合的逆向迭代，但是从Java集合框架之Collection接口中我们知道，迭代器初始状态下前面并没有任何元素，必须先正向遍历，才能逆向遍历，所以一般不使用逆向迭代。

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class ListDemo5 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("西游记");
13         list.add("水浒传");
14 
15         ListIterator it = list.listIterator();
16         
17         System.out.println("----------逆向迭代----------");
18         while (it.hasPrevious()) {
19             Object object = (Object) it.previous();
20             System.out.println(object);
21         }
22 
23         System.out.println("----------正向迭代----------");
24         while (it.hasNext()) {
25             Object object = it.next();
26             System.out.println(object);
27         }
28         
29         System.out.println("----------逆向迭代----------");
30         while (it.hasPrevious()) {
31             Object object = (Object) it.previous();
32             System.out.println(object);
33         }
34     }
35 }

输出结果

----------逆向遍历----------
----------正向遍历----------
红楼梦
三国演义
西游记
水浒传
----------逆向遍历----------
水浒传
西游记
三国演义
红楼梦

从上面结果可以看出，当第一次逆向迭代的时候并没有任何输出，当正向迭代后，迭代器到了集合的末尾之后，再次逆向迭代，这时才有输出。

上面的while循环，我们可以改成for循环

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 public class ListDemo6 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("西游记");
13         list.add("水浒传");
14 
15         for (Iterator iterator = list.iterator(); iterator.hasNext();) {
16             Object object = (Object) iterator.next();
17             System.out.println(object);
18         }
19     }
20 }

在效率上，或许for循环的更高，因为for循环结束之后iterator变量的作用域便结束了，iterator变量就消失了。我们还可以结合get(int index)与size()方法来遍历集合

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class ListDemo7 {
 7     public static void main(String[] args) {
 8         List list = new ArrayList();
 9         list.add("红楼梦");
10         list.add("三国演义");
11         list.add("西游记");
12         list.add("水浒传");
13 
14         for (int i = 0; i < list.size(); i++) {
15             Object object = list.get(i);
16             System.out.println(object);
17         }
18     }
19 }

下面再来看ListIterator中对元素进行操作的方法

void add(E e)：将指定的元素插入列表

void remove()：从列表中移除由 next 或 previous 返回的最后一个元素

void set(E e)：用指定元素替换 next 或 previous 返回的最后一个元素

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class ListDemo8 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("西游记");
13         list.add("水浒传");
14 
15         ListIterator it = list.listIterator();
16 
17         it.add("平凡的世界");
18 
19         System.out.println(list);
20 
21         it.next();
22         it.remove(); // 调用remove方法时需要先调用next或
23                         // previous方法，否则将抛出java.lang.IllegalStateException异常
24         it.next();
25         it.set("新三国演义");// 调用remove方法时需要先调用next或
26                         // previous方法，否则将抛出java.lang.IllegalStateException异常
27 
28         System.out.println(list);
29     }
30 }

输出结果

[平凡的世界, 红楼梦, 三国演义, 西游记, 水浒传]
[平凡的世界, 新三国演义, 西游记, 水浒传]
西游记
水浒传

有时候我们在操作集合的时候，需要对集合的元素进行添加或者是删除

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 import java.util.List;
 6 
 7 public class ListDemo9 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("水浒传");
13 
14         Iterator it = list.iterator();
15 
16         while (it.hasNext()) {
17             String s = (String) it.next();
18             if ("三国演义".equals(s)) {
19                 list.add("西游记");
20             }
21         }
22 
23         System.out.println(list);
24     }
25 }

运行这段程序，控制台将出现如下错误

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at list.ListDemo9.main(ListDemo9.java:17)

ConcurrentModificationException：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 为什么会出现这种错误呢，这是因为迭代器是依赖于集合而存在的，在判断成功后，集合中新添加了元素，而迭代器这时还不知道，所以就报错了，这个错叫并发修改异常。报错的地方为代码17行，正是迭代器获取元素的时候。如何解决这个问题呢，既然迭代器遍历集合的时候，集合不能对元素进行操作，那么使用迭代器操作元素呢

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class ListDemo10 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("水浒传");
13 
14         ListIterator it = list.listIterator();
15 
16         while (it.hasNext()) {
17             String s = (String) it.next();
18             if ("三国演义".equals(s)) {
19                 it.add("西游记");
20             }
21         }
22 
23         System.out.println(list);
24     }
25 }

这时候控制台的没有报错了

[红楼梦, 三国演义, 西游记, 水浒传]

用迭代器添加的元素时，元素的位置为当前迭代器的位置，换个角度想一下，既然迭代器遍历集合的时候，迭代器可以对集合的元素进行操作，那么集合遍历元素的时候，集合是否也可以对元素进行操作呢

 1 package list;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.ListIterator;
 6 
 7 public class ListDemo10 {
 8     public static void main(String[] args) {
 9         List list = new ArrayList();
10         list.add("红楼梦");
11         list.add("三国演义");
12         list.add("水浒传");
13 
14         for (int i = 0; i < list.size(); i++) {
15             if ("水浒传".equals(list.get(i))) {
16                 list.add("西游记");
17             }
18         }
19 
20         System.out.println(list);
21     }
22 }

输出结果

[红楼梦, 三国演义, 水浒传, 西游记]

当用集合添加元素的时候，添加在了集合的最后面

由上述结果可以知，有两种方法可以解决并发修改异常ConcurrentModificationException

1、迭代器迭代元素，迭代器修改元素

2、集合遍历元素，集合修改元素(普通for)

Java集合框架之List接口


联系
我们