JAVA迭代器(Interator)详解

一、迭代器概述

1、什么是迭代器?

在Java中,有很多的数据容器,对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离,达到解耦的效果。

在Iterator接口中定义了四个方法:

方法 功能
default void forEachRemaining(Consumer<? super E> action) 对每个剩余元素执行给定的操作,直到所有元素都被处理或动作引发异常。
boolean hasNext() 如果迭代具有更多元素,则返回 true 。
E next() 返回迭代中的下一个元素。
default void remove() 从底层集合中删除此迭代器返回的最后一个元素(可选操作)。

2、迭代器使用

1
2
3
4
5
6
7
8
9
10
11
12
13
public void testIterator() {
Collection collection = new ArrayList();
collection.add(123);
collection.add("AA");
collection.add(new Date());
collection.add("BB");
collection.add(new Employee("Caole",23));

Iterator iterator = collection.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}

执行结果:

1
2
3
4
5
123
AA
Wed Nov 01 17:53:43 CST 2017
BB
Employee{id=598, name='Caole', salary=23.0}

二、ArrayList的Iterator实现

前段代码的输出结果不用多说,这里的iterator更像是“游标”,不过这游标具体做了啥,我们还得通过list.iterator()好好看看。通过源码了解到该方法产生了一个实现Iterator接口的对象。

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;

public boolean hasNext() {
return cursor != size;
}

@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}

public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

其中:

1
2
3
4
5
6
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
...
}

在ArrayList内部定义了一个内部类Itr,该类实现了Iterator接口。

在Itr中,有三个变量分别是

  • cursor:表示下一个元素的索引位置
  • lastRet:表示上一个元素的索引位置
  • expectModCount:预期被修改的次数

下面看一下Itr类实现了Iterator接口的三个方法:

1
2
3
public boolean hasNext() {
return cursor != size;//当cursor不等于size时,表示仍有索引元素
}
1
2
3
4
5
6
7
8
9
10
11
public E next() //返回下一个元素{
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}

在next()方法中有一个checkForComodification()方法,其实现为:

1
2
3
4
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

可以看到,该函数是用来判断集合的修改次数是否合法。

  在集合内部维护一个字段modCount用于记录集合被修改的次数,每当集合内部结构发生变化(add,remove,set)时,modCount+1。

  在迭代器内部也维护一个字段expectedModCount,同样记录当前集合修改的次数,初始化为集合的modCount值。当我们在调用Iterator进行遍历操作时,如果有其他线程修改list会出现modCount!=expectedModCount的情况,就会报并发修改异常java.util.ConcurrentModificationException。下面为示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args)
{
ArrayList<String> aList=new ArrayList<String>();
aList.add("bbc");
aList.add("abc");
aList.add("ysc");
aList.add("saa");
System.out.println("移除前:"+aList);

Iterator<String> it=aList.iterator();
while(it.hasNext())
{
if("abc".equals(it.next()))
{
aList.remove("abc");
}
}
System.out.println("移除后:"+aList);
}
1
2
3
4
5
移除前:[bbc, abc, ysc, saa]

java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)

上面的代码中,如果我们只使用迭代器来进行删除,则不会出现并发修改异常错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args)
{
    ArrayList<String> aList=new ArrayList<String>();
aList.add("bbc");
aList.add("abc");
aList.add("ysc");
aList.add("saa");
System.out.println("移除前:"+aList);

Iterator<String> it=aList.iterator();
while(it.hasNext())
{
if("abc".equals(it.next()))
{
it.remove();
}
}
System.out.println("移除后:"+aList);
}

1
2
移除前:[bbc, abc, ysc, saa]
移除后:[bbc, ysc, saa]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void remove()
{
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。

三、ListIterator

上面可以看到,Iterator只提供了删除元素的方法remove,如果我们想要在遍历的时候添加元素怎么办?

ListIterator接口继承了Iterator接口,它允许程序员按照任一方向遍历列表,迭代期间修改列表,并获得迭代器在列表中的当前位置。

ListIterator接口定义了下面几个方法:

方法 说明
void add(E e) 将指定的元素插入列表(可选操作)。
boolean hasNext() 返回 true如果遍历正向列表,列表迭代器有多个元素。
boolean hasPrevious() 返回 true如果遍历反向列表,列表迭代器有多个元素。
E next() 返回列表中的下一个元素,并且前进光标位置。
int nextIndex() 返回随后调用 next()返回的元素的索引。
E previous() 返回列表中的上一个元素,并向后移动光标位置。
int previousIndex() 返回由后续调用 previous()返回的元素的索引。
void remove() 从列表中删除由 next()或 previous()返回的最后一个元素(可选操作)。
void set(E e) 用 指定的元素替换由 next()或 previous()返回的最后一个元素(可选操作)。

下面使用ListIterator来对list进行边遍历边添加元素操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args)
{
ArrayList<String> aList = new ArrayList<String>();
aList.add("bbc");
aList.add("abc");
aList.add("ysc");
aList.add("saa");
System.out.println("移除前:" + aList);
ListIterator<String> listIt = aList.listIterator();
while (listIt.hasNext())
{
if ("abc".equals(listIt.next()))
{
listIt.add("haha");
}
}
System.out.println("移除后:" + aList);
}

1
2
移除前:[bbc, abc, ysc, saa]
移除后:[bbc, abc, haha, ysc, saa]
0%