Java基础 -- 深入理解迭代器

在Java基础 -- 持有对象(容器)已经详细介绍到，集合(Collection)的种类有很多种，比如ArrayList、LinkedList、HashSet...。

由于集合的内部结构不同，很多时候可能不知道该怎样去遍历一个集合中的元素。所以为了使对集合内元素的操作更为简单，Java引入了迭代器模式！

一 为什么使用迭代器

迭代器把访问逻辑从不同类型的集合类型中抽取出来，从而避免向外部暴露集合的内部结构。

对于数组我们使用的是下标来进行处理的：

1 int array[] = new int[3];    
2 for (int i = 0; i < array.length; i++) {
3     System.out.println(array[i]);
4 }

对ArrayList的处理:

1 List<String> list = new ArrayList<String>();
2        for(int i = 0 ; i < list.size() ;  i++){
3           String string = list.get(i);
4 }

对于这两种方式，我们总是都知道它的内部结构，访问代码和集合本身是紧密耦合的，无法将访问逻辑从集合类和客户端代码中分离出来。不同的集合会对应不同的遍历方法，客户端代码无法复用。在实际应用中如何将上面两个集合整合是相当麻烦的。所以才有Iterator，它总是用同一种逻辑来遍历集合。使得客户端自身不需要来维护集合的内部结构，所有的内部状态都由Iterator来维护。客户端不用直接和集合进行打交道，而是控制Iterator向它发送向前向后的指令，就可以遍历集合。

二 迭代器的使用

迭代器通常被称为轻量级对象；创建它的代价小，因此，经常可以看到对迭代器有些奇怪的限制，例如，Java的Iterator只能单向移动，这个Iterator只能用来：

• 使用方法iterator()要求集合返回一个Iterator，Iterator将准备好返回集合的第一个元素；
• 使用next()获取集合中的下一个元素；
• 使用hasNext()检查集合中是否还存在元素；
• 使用remove()将迭代器新近返回的元素删除；

1、Iterator接口

为了观察它的工作方式，让我们来看一个例子：

import java.util.*;

public class SimpleIteration {
    public static void main(String[] args) {
        //默认从小到大排序
        List<Person> pers = new ArrayList<Person>();
        
        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);
        
        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);
        
        Person p3 = new Person("张三",17,true);
        pers.add(p3);
        
        Person p4 = new Person("李四",34,false);
        pers.add(p4);
        
        Iterator<Person> it = pers.iterator();
        //检查list中是否还有元素
        while(it.hasNext()) {
            //获取list中下一个元素
            Person p = it.next();
            System.out.print(p + "  ");
        }
        System.out.println();
        
        
        it = pers.iterator();
        for(int i=0;i<4;i++) {
            //获取list中下一个元素
            it.next();
            //将迭代器新近返回的元素删除
            it.remove();
            System.out.println(i + ":" + pers);
        }
        System.out.print(pers);
        
    }
}

 输出结果如下：

吴定会-50-true  沈艳霞-46-false  张三-17-true  李四-34-false  
0:[沈艳霞-46-false, 张三-17-true, 李四-34-false]
1:[张三-17-true, 李四-34-false]
2:[李四-34-false]
3:[]
[]

现在考虑创建一个display()方法，它不必知晓集合的确切类型：

import java.util.*;

public class CrossContainerIteration {
    public static void display(Iterator<Person> it) {
        while(it.hasNext()) {
            Person p = it.next();
            System.out.print(p + " ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        ArrayList<Person> pers = new ArrayList<Person>();
        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);
        
        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);
        
        Person p3 = new Person("张三",17,true);
        pers.add(p3);
        
        Person p4 = new Person("李四",34,false);
        pers.add(p4);
        
        LinkedList<Person> persLL = new LinkedList<Person>(pers);
        HashSet<Person> persHS = new HashSet<Person>(pers);        
        
        display(pers.iterator());
        display(persLL.iterator());
        display(persHS.iterator());        
    }
}

 输出：

吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false 
吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false 
张三-17-true 吴定会-50-true 沈艳霞-46-false 李四-34-false 

 可以看到display()方法不包含任何有关它所遍历的集合的类型信息，而这也展示了Iterator的真正威力，能够将遍历集合的操作与集合底层结构分离。正因为如此，我们有时才会说，迭代器统一了对集合的访问方式。

2、ListIterator

ListIterator是一个更加强大的Iterator的子类型，它只能用于各种List类的访问，尽管Iterator只能向前移动，但是ListIterator可以双向移动。它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引，并且可以使用set()方法替代它访问过的最后一个元素。可以通过调用listIterrator()方法产生一个指向List开始处的ListIterator，并且还可以通过调用listIterator(n)方法创建一个一开始指向列表索引为n的元素处的ListIterator。下面的示例演示了所有这些能力：

import java.util.*;

public class ListIteration {
    public static void main(String[] args) {
        List<Person> pers = new ArrayList<Person>();
        Person p1 = new Person("吴定会",50,true);
        pers.add(p1);
        
        Person p2 = new Person("沈艳霞",46,false);
        pers.add(p2);
        
        Person p3 = new Person("张三",17,true);
        pers.add(p3);
        
        Person p4 = new Person("李四",34,false);
        pers.add(p4);
        
        //从前向后遍历
        ListIterator<Person> it = pers.listIterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");            
        }
        System.out.println();
        
        //从后向前遍历
        while(it.hasPrevious()) {
            System.out.print(it.previous() + " ");
        }
        System.out.println();
        System.out.println(pers);
        
        //创建一个开始指向第三个索引元素处的ListIterator
        it = pers.listIterator(3);
        while(it.hasNext()) {
            System.out.println(it.next());
                        //替换在列表中从位置3开始向前的所有Person对象  
            it.set(p1);
        }
        System.out.println(pers);
    } 
}

 输出：

吴定会-50-true 沈艳霞-46-false 张三-17-true 李四-34-false 
李四-34-false 张三-17-true 沈艳霞-46-false 吴定会-50-true 
[吴定会-50-true, 沈艳霞-46-false, 张三-17-true, 李四-34-false]
李四-34-false
[吴定会-50-true, 沈艳霞-46-false, 张三-17-true, 吴定会-50-true]

三 迭代器的实现

1、下面让我们看看Java中的Iterator接口是如何实现的

在Java中Iterator为一个接口，它只提供了迭代的基本规则。在JDK中它是这样定义的：对Collection进行迭代的迭代器。迭代器取代了Java Collection Framework中的Enumeration。迭代器与枚举有两点不同:

• 迭代器在迭代期间可以从集合中移除元素。
• 方法名得到了改进，Enumeration的方法名称都比较长。

其接口定义如下:

package java.util;
public interface Iterator<E> {
    boolean hasNext();//判断是否存在下一个对象元素

    E next();//获取下一个元素

    void remove();//移除元素
}

2、Iterable

Java中还提供了一个Iterable接口，Iterable接口实现后的功能是返回一个迭代器，我们常用的实现了该接口的子接口有:Collection<E>、List<E>、Set<E>等。该接口的iterator()方法返回一个标准的Iterator实现。实现Iterable接口允许对象成为foreach语句的目标。就可以通过foreach语句来遍历你的底层序列。

Iterable接口包含一个能产生Iterator对象的方法，并且Iterable被foreach用来在序列中移动。因此如果创建了实现Iterable接口的类，都可以将它用于foreach中。

Iterable接口的具体实现:

Package java.lang;

import java.util.Iterator;
public interface Iterable<T> {
    Iterator<T> iterator();
}

 使用迭代器遍历集合:

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");
        
        List<String> linkList = new LinkedList<String>();
        linkList.add("link1");
        linkList.add("link2");
        linkList.add("link3");
        linkList.add("link4");
        
        Set<String> set = new HashSet<String>();
        set.add("set1");
        set.add("set2");
        set.add("set3");
        set.add("set4");
        //使用迭代器遍历ArrayList集合
        Iterator<String> listIt = list.iterator();
        while(listIt.hasNext()){
            System.out.println(listIt.next());
        }
        //使用迭代器遍历Set集合
        Iterator<String> setIt = set.iterator();
        while(setIt.hasNext()){
            System.out.println(listIt.next());
        }
        //使用迭代器遍历LinkedList集合
        Iterator<String> linkIt = linkList.iterator();
        while(linkIt.hasNext()){
            System.out.println(listIt.next());
        }
}

 使用foreach遍历集合:

List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");
        for (String string : list) {
            System.out.println(string);
        }

 可以看出使用foreach遍历集合的优势在于代码更加的简洁，更不容易出错，不用关心下标的起始值和终止值。

3、Iterator遍历时不可以删除集合中的元素问题

在使用Iterator的时候禁止对所遍历的容器进行改变其大小结构的操作。例如: 在使用Iterator进行迭代时，如果对集合进行了add、remove操作就会出现ConcurrentModificationException异常。

List<String> list = new ArrayList<String>();
        list.add("张三1");
        list.add("张三2");
        list.add("张三3");
        list.add("张三4");
        
        //使用迭代器遍历ArrayList集合
        Iterator<String> listIt = list.iterator();
        while(listIt.hasNext()){
            Object obj = listIt.next();
            if(obj.equals("张三3")){
                list.remove(obj);
            }
        }

因为在你迭代之前，迭代器已经被通过list.itertor()创建出来了，如果在迭代的过程中，又对list进行了改变其容器大小的操作，那么Java就会给出异常。因为此时Iterator对象已经无法主动同步list做出的改变，Java会认为你做出这样的操作是线程不安全的，就会给出善意的提醒（抛出ConcurrentModificationException异常）

Iterator的实现源码:　　

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();
            }
        }

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

通过查看源码发现原来检查并抛出异常的是checkForComodification()方法。在ArrayList中modCount是当前集合的版本号，每次修改(增、删)集合都会加1；expectedModCount是当前迭代器的版本号，在迭代器实例化时初始化为modCount。我们看到在checkForComodification()方法中就是在验证modCount的值和expectedModCount的值是否相等，所以当你在调用了ArrayList.add()或者ArrayList.remove()时，只更新了modCount的状态，而迭代器中的expectedModCount未同步，因此才会导致再次调用Iterator.next()方法时抛出异常。但是为什么使用Iterator.remove()就没有问题呢？通过源码的第32行发现，在Iterator的remove()中同步了expectedModCount的值，所以当你下次再调用next()的时候，检查不会抛出异常。

使用该机制的主要目的是为了实现ArrayList中的快速失败机制（fail-fast），在Java集合中较大一部分集合是存在快速失败机制的。

快速失败机制产生的条件:当多个线程对Collection进行操作时，若其中某一个线程通过Iterator遍历集合时，该集合的内容被其他线程所改变，则会抛出ConcurrentModificationException异常。

所以要保证在使用Iterator遍历集合的时候不出错误，就应该保证在遍历集合的过程中不会对集合产生结构上的修改。

使用Foreach时对集合的结构进行修改会出现异常:

上面我们说了实现了Iterable接口的类就可以通过Foreach遍历，那是因为foreach要依赖于Iterable接口返回的Iterator对象，所以从本质上来讲，Foreach其实就是在使用迭代器，在使用foreach遍历时对集合的结构进行修改，和在使用Iterator遍历时对集合结构进行修改本质上是一样的。所以同样的也会抛出异常，执行快速失败机制。

foreach是JDK1.5新增加的一个循环结构，foreach的出现是为了简化我们遍历集合的行为。

for循环与迭代器的对比:

* 效率上各有各的优势:

• ArrayList对随机访问比较快，而for循环中使用的get()方法，采用的即是随机访问的方法，因此在ArrayList里for循环快。
• LinkedList则是顺序访问比较快，Iterator中的next()方法采用的是顺序访问方法，因此在LinkedList里使用Iterator较快。

参考文献：

[1] Java编程思想

[2] 深入理解Java中的迭代器(部分转载)