Java Iterator ListIterator 迭代器以及并发修改异常 ConcurrentModificationException

最新推荐文章于 2022-09-28 14:50:12 发布

马大头

最新推荐文章于 2022-09-28 14:50:12 发布

阅读量1.1k

点赞数 2

分类专栏： Java

Java 专栏收录该内容

90 篇文章 1 订阅

订阅专栏

迭代器内部定义了一个 cursor 变量，用来指示当前遍历到了什么位置。每次调用 next() 或 previous() 对该值做出相应的递增或递减操作，以此实现顺序迭代。
当调用 hasNext() 方法时，判断 cursor 变量是否等于集合大小，如果不等于，说明后面还有元素可以正序迭代。
当调用 hasPrevious() 方法时，判断 cursor 变量是否小于 0 ，如果不等于，说明前面还有元素可以倒序迭代。

Iterator 迭代器

方法示例

ArrayList<Character> list = new ArrayList<>();
// 添加元素
for (char c = 'A'; c <= 'G'; c++) {
    list.add(c);
}

Iterator<Character> it = list.iterator();

// hasNext() 判断是否还有元素可以迭代
while (it.hasNext()) {
    char c = it.next(); // next() 返回下一个元素

    if (c == 'C') {
        it.remove(); // remove() 移除元素
    } else {
        System.out.print(c + ", ");
    }
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果
Iterator 的方法

方法功能
hasNext() 判断集合列表中是否还有可以迭代的元素
next() 返回下一个元素
remove() 移除最近返回的一个元素

方法	功能
hasNext()	判断集合列表中是否还有可以迭代的元素
next()	返回下一个元素
remove()	移除最近返回的一个元素

ListIterator 迭代器

方法示例

ArrayList<Integer> list = new ArrayList<>();
// 添加元素
for (int i = 1; i <= 3; i++) {
    list.add(i);
}

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

boolean flag = true;

// 如果是正序迭代 或者 有前一个可以迭代的元素
while (flag || li.hasPrevious()) {
    int index = 0;
    int ele = 0;

    if (flag) {
        index = li.nextIndex(); // nextIndex() 返回下一个元素的索引
        ele = li.next(); // next() 返回下一个元素
    } else {
        index = li.previousIndex(); // previousIndex 返回上一个元素的索引
        ele = li.previous(); // previous() 返回上一个元素
    }

    if (ele == 1) {
        // 如果迭代到的元素是 1 ，则将该元素替换成 0
        li.set(0); // set() 用指定元素替换最后返回的元素
    } else if (ele == 3) {
        li.remove(); // remove() 移除最后返回的元素
    }

    System.out.println("(" + index + ") = " + ele);

    // 判断是否还有下一个可以迭代的元素
    if (!li.hasNext()) {
        flag = false;
        li.add(10); // add() 添加一个元素
    }

}
   
   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
   
   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

运行结果

ListIterator 的方法

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

并发修改异常

简单来讲，并发修改异常就是在对集合元素进行迭代的时候，集合本身发生了改变，所以抛出此异常。先来看一个示例。

示例

ArrayList<Character> list = new ArrayList<>();
// 添加元素
for (char c = 'A'; c <= 'G'; c++) {
    list.add(c);
}

// 获得集合的迭代器
Iterator<Character> it = list.iterator();

while (it.hasNext()) {
    char c = it.next();

    if (c == 'D') {
        list.remove(new Character(c));
    }

    System.out.println(c);
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果
原因
- 上面已经提到，并发修改异常是在迭代过程中，被迭代的集合发生了变化才引发的。那么看下面代码中用蓝色标识的代码，这里显然对集合中的元素进行了移除操作。
- 需要注意的是，该异常并不是移除操作引发的，而是上面用红色标识的代码，也就是下一次循环去获取集合元素的时候引发的。具体是怎么回事这要讲一下源码，看下图。
- 源代码 next() 方法中，调用了一个 checkForComodification() 方法，这是什么呢？继续跟下去看一下。
- 看上图，代码显示，如果 modCount 不等于 expectedModCount 则抛出并发修改异常。那么这两个变量都是什么意思呢？我们继续分析源码。
  
  集合在创建时： modCount 的值默认是 0 那么这个值在什么情况下会发生变化呢？
- 首先，我们看添加元素 add() 方法。
  
  这里调用了一个 ensureCapacityInternal() 方法，跟下去看一下。
- 看上面的图片，在调用 ensureCapacityInternal() 方法后，ensureCapacityInternal() 方法里又调用了一个 ensureExplicitCapacity() 方法，而 modCount 值的改变就是发生在这个方法里，当然，在 add()方法调用 ensureCapacityInternal() 之前，元素的添加操作就以及完成了，实际上包括 remove()、set() 操作最后都会递增 modCound。也就是说，只要对集合进行了操作，这个 modCount 值就会递增一次。
- 现在，我们搞清楚了 modCount 是怎么回事，那 expectedModCount 又是怎么回事呢？看下图。
- 当我们调用集合的 iterator() 方法获得迭代器时，底层实际上是给我们 new 了一个 Itr 内部类对象，这个内部类实现了 Iterator 接口。
- 看上图箭头标识 1 的位置，在创建迭代器 Itr 对象的时候，先用 expectedModCount 把集合的 modCount 值记录下来。
- 讲到这里，再返回上面看一下前面说到的调用迭代器的 next() 为什么引发并发修改异常就明白怎么回事了。

总结

实现了 Iterator 迭代器接口的集合都可以使用迭代器对其元素进行遍历。
ListIterator 可以再迭代时对集合进行 add、set、remove 操作，而 Iterator 迭代器只能在迭代时对集合进行 remove 操作。
不允许在迭代时对集合进行操作，当然，使用迭代器本身提供的方法除外，原因这里不再图文分析，简单说一下吧，在使用迭代器本身提供的方法对集合操作后，expectedModCount 的值也会相应递增，所以下次检查是就不会有问题。感兴趣的朋友可以自己去看一下源代码。