水滴石穿-Iterator和ListIterator的基本使用

本文最后更新于：May 21, 2022 pm

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

一般对集合进行遍历的时候，用的最多的应该是 Iterator，但是Iterator是不能对集合内的元素做出添加或者删除的修改操作！！！否则会报错“并发修改异常”。但是ListIterator却可以做到对集合进行修改之类的操作。

java中的ListIterator在Iterator基础上提供了add、set、previous等对列表的操作。所以两者用法类似，Iterator的遍历和ListIterator一样，所以，此篇博文只记录ListIterator的用法，而Iterator参考使用即可。两者的区别在于获取迭代器的方式不同，如下：

1
2
3
List<Integer> list = new ArrayList<>();
Iterator im = list.iterator();
ListIterator<Integer> it = list.listIterator();

ListIterator

ListIterator跟Iterator一样，仍是在原列表上进行操作。

遍历分为正序遍历（hasNext()）和反序遍历（hasPrevious()）。

方法 功能
hasNext() 判断是否还有下一个元素可以迭代
next() 返回下一个元素
hasPrevious() 判断是否还有上一个元素可以迭代
previous() 返回上一个元素
add() 返回上一个元素
set(E e) 用指定的元素替换最近返回的元素
remove() 移除最近返回的元素

hasNext

正序遍历，从头到尾。配合next()进行移动。

遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){
    System.out.println(it.next());
  }
}

//
1
4
7

添加

可以在当前位置的前或后进行插入一个或多个数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){
    it.add(33);
    it.add(333);
    System.out.println(it.next());
    it.add(44);
    it.add(444);
  }
  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    System.out.println(it.next());
  }

}

//输出
1
4
7
================
33
333
1
44
444
33
333
4
44
444
33
333
7
44
444

修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){
    it.add(33);
    System.out.println(it.next());
    it.add(44);
  }
  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    it.next();
    it.set(777);
  }
  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    System.out.println(it.next());
  }

}

//输出
1
4
7
================
================
777
777
777
777
777
777
777
777
777

删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){
    it.add(33);
    System.out.println(it.next());
    it.add(44);
  }
  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    System.out.println(it.next());
  }
  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    it.next();
    it.remove(); 
  }

  it = list.listIterator();
  System.out.println("================");
  while(it.hasNext()){
    System.out.println(it.next());
  }

}
//输出
1
4
7
================
33
1
44
33
4
44
33
7
44
================
================

hasPrevious

反序遍历，从尾到头。所以就有一个前提条件，当前迭代器的位置必须是在最后。

遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){ //让迭代器到最后位置
    it.next();
  }
  while(it.hasPrevious()){
    System.out.println(it.previous());
  }

}

//输出
7
4
1

添加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){ //让迭代器到最后位置
    it.next();
  }
  while(it.hasPrevious()){
    it.previous();
    it.add(3232);
    it.previous();
  }

  System.out.println("=========");
  while(it.hasNext()){
    System.out.println(it.next());
  }
}

//输出
=========
3232
1
3232
4
3232
7

修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){ //让迭代器到最后位置
    it.next();
  }
  while(it.hasPrevious()){
    it.previous();
    it.set(777);
  }

  System.out.println("=========");
  while(it.hasNext()){
    System.out.println(it.next());
  }
}
//输出
=========
777
777
777

删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static void main(String[] args) throws Exception {

  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(4);
  list.add(7);

  ListIterator<Integer> it = list.listIterator();

  while(it.hasNext()){ //让迭代器到最后位置
    it.next();
  }
  while(it.hasPrevious()){
    it.previous();
    it.remove();
  }

  System.out.println("=========");
  while(it.hasNext()){
    System.out.println(it.next());
  }
}

//输出
=========