行为型：设计模式之迭代器模式（二十一）

 20世纪80年代，那时我家有一台“古老的”电视机，牌子我忘了，只记得是台黑白电视机，没有遥控器，每次开关机或者换台都需要通过电视机上面的那些按钮来完成，我印象最深的是那个用来换台的按钮，需要亲自用手去旋转（还要使点劲才能拧动），每转一下就“啪”的响一声，如果没有收到任何电视频道就会出现一片让人眼花的雪花点。当然，电视机上面那两根可以前后左右移动，并能够变长变短的天线也是当年电视机的标志性部件之一，我记得小时候每次画电视机时一定要画那两根天线，要不总觉得不是电视机，

。随着科技的飞速发展，越来越高级的电视机相继出现，那种古老的电视机已经很少能够看到了。与那时的电视机相比，现今的电视机给我们带来的最大便利之一就是增加了电视机遥控器，我们在进行开机、关机、换台、改变音量等操作时都无须直接操作电视机，可以通过遥控器来间接实现。我们可以将电视机看成一个存储电视频道的集合对象，通过遥控器可以对电视机中的电视频道集合进行操作，如返回上一个频道、跳转到下一个频道或者跳转至指定的频道。遥控器为我们操作电视频道带来很大的方便，用户并不需要知道这些频道到底如何存储在电视机中。电视机遥控器和电视机示意图如图1所示： 

图1 电视机遥控器与电视机示意图

(Aggregate Classes)，对应的对象称为聚合对象。为了更加方便地操作这些聚合对象，同时可以很灵活地为聚合对象增加不同的遍历方法，我们也需要类似电视机遥控器一样的角色，可以访问一个聚合对象中的元素但又不需要暴露它的内部结构。本章我们将要学习的迭代器模式将为聚合对象提供一个遥控器，通过引入迭代器，客户端无须了解聚合对象的内部结构即可实现对聚合对象中成员的遍历，还可以根据需要很方便地增加新的遍历方式。

1 销售管理系统中数据的遍历

Sunny软件公司开发人员通过对AbstractObjectList类结构进行分析，发现该设计方案存在如下几个问题：

        (1) 在图2所示类图中，addObject()、removeObject()等方法用于管理数据，而next()、isLast()、previous()、isFirst()等方法用于遍历数据。这将导致聚合类的职责过重，它既负责存储和管理数据，又负责遍历数据，违反了“单一职责原则”，由于聚合类非常庞大，实现代码过长，还将给测试和维护增加难度。

        (2) 如果将抽象聚合类声明为一个接口，则在这个接口中充斥着大量方法，不利于子类实现，违反了“接口隔离原则”。

        (3) 如果将所有的遍历操作都交给子类来实现，将导致子类代码庞大，而且必须暴露AbstractObjectList的内部存储细节，向子类公开自己的私有属性，否则子类无法实施对数据的遍历，这将破坏AbstractObjectList类的封装性。

       如何解决上述问题？解决方案之一就是将聚合类中负责遍历数据的方法提取出来，封装到专门的类中，实现数据存储和数据遍历分离，无须暴露聚合类的内部属性即可对其进行操作，而这正是迭代器模式的意图所在。

2 迭代器模式概述

       在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

       迭代器模式定义如下：

       在迭代器模式结构中包含聚合和迭代器两个层次结构，考虑到系统的灵活性和可扩展性，在迭代器模式中应用了工厂方法模式，其模式结构如图3所示：

图3 迭代器模式结构图

       在迭代器模式结构图中包含如下几个角色：

       ● Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

       ● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

       ● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

      ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

       在迭代器模式中，提供了一个外部的迭代器来对聚合对象进行访问和遍历，迭代器定义了一个访问该聚合元素的接口，并且可以跟踪当前遍历的元素，了解哪些元素已经遍历过而哪些没有。迭代器的引入，将使得对一个复杂聚合对象的操作变得简单。

       下面我们结合代码来对迭代器模式的结构进行进一步分析。在迭代器模式中应用了工厂方法模式，抽象迭代器对应于抽象产品角色，具体迭代器对应于具体产品角色，抽象聚合类对应于抽象工厂角色，具体聚合类对应于具体工厂角色。

       在抽象迭代器中声明了用于遍历聚合对象中所存储元素的方法，典型代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. interface Iterator {  
2. public void first(); //将游标指向第一个元素  
3. public void next(); //将游标指向下一个元素  
4. public boolean hasNext(); //判断是否存在下一个元素  
5. public Object currentItem(); //获取游标指向的当前元素  
6. }  

在具体迭代器中将实现抽象迭代器声明的遍历数据的方法，如下代码所示：

[java]  ​​view plain​​ ​​copy​​

1. class ConcreteIterator implements Iterator {  
2. private ConcreteAggregate objects; //维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据  
3. private int cursor; //定义一个游标，用于记录当前访问位置  
4. public ConcreteIterator(ConcreteAggregate objects) {  
5. this.objects=objects;  
6.     }  
7.   
8. public void first() {  ......  }  
9.           
10. public void next() {  ......  }  
11.   
12. public boolean hasNext() {  ......  }  
13.       
14. public Object currentItem() {  ......  }  
15. }  

       需要注意的是抽象迭代器接口的设计非常重要，一方面需要充分满足各种遍历操作的要求，尽量为各种遍历方法都提供声明，另一方面又不能包含太多方法，接口中方法太多将给子类的实现带来麻烦。因此，可以考虑使用抽象类来设计抽象迭代器，在抽象类中为每一个方法提供一个空的默认实现。如果需要在具体迭代器中为聚合对象增加全新的遍历操作，则必须修改抽象迭代器和具体迭代器的源代码，这将违反“开闭原则”，因此在设计时要考虑全面，避免之后修改接口。

       聚合类用于存储数据并负责创建迭代器对象，最简单的抽象聚合类代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. interface Aggregate {  
2.     Iterator createIterator();  
3. }  

       具体聚合类作为抽象聚合类的子类，一方面负责存储数据，另一方面实现了在抽象聚合类中声明的工厂方法createIterator()，用于返回一个与该具体聚合类对应的具体迭代器对象，代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. class ConcreteAggregate implements Aggregate {    
2.     ......    
3. public Iterator createIterator() {  
4. return new ConcreteIterator(this);  
5.     }  
6.     ......  
7. }  

3 完整解决方案

AbstractObjectList类的结构，并给不同的具体数据集合类提供不同的遍历方式，Sunny软件公司开发人员使用迭代器模式来重构AbstractObjectList类的设计，重构之后的销售管理系统数据遍历结构如图4所示：

图4 销售管理系统数据遍历结构图

（注：为了简化类图和代码，本结构图中只提供一个具体聚合类和具体迭代器类）

4中，AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。完整代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. //在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历  
2. import java.util.*;  
3.   
4. //抽象聚合类  
5. public abstract class AbstractObjectList {  
6. protected List<Object> objects = new ArrayList<Object>();  
7.   
8. public AbstractObjectList(List objects) {  
9. this.objects = objects;  
10.     }  
11.       
12. public void addObject(Object obj) {  
13. this.objects.add(obj);  
14.     }  
15.       
16. public void removeObject(Object obj) {  
17. this.objects.remove(obj);  
18.     }  
19.       
20. public List getObjects() {  
21. return this.objects;  
22.     }  
23.       
24. //声明创建迭代器对象的抽象工厂方法  
25. public abstract AbstractIterator createIterator();  
26. }  
27.   
28. //商品数据类：具体聚合类  
29. class ProductList extends AbstractObjectList {  
30. public ProductList(List products) {  
31. super(products);  
32.     }  
33.       
34. //实现创建迭代器对象的具体工厂方法  
35. public AbstractIterator createIterator() {  
36. return new ProductIterator(this);  
37.     }  
38. }   
39.   
40. //抽象迭代器  
41. public interface AbstractIterator {  
42. public void next(); //移至下一个元素  
43. public boolean isLast(); //判断是否为最后一个元素  
44. public void previous(); //移至上一个元素  
45. public boolean isFirst(); //判断是否为第一个元素  
46. public Object getNextItem(); //获取下一个元素  
47. public Object getPreviousItem(); //获取上一个元素  
48. }  
49.   
50. //商品迭代器：具体迭代器  
51. class ProductIterator implements AbstractIterator {  
52. private ProductList productList;  
53. private List products;  
54. private int cursor1; //定义一个游标，用于记录正向遍历的位置  
55. private int cursor2; //定义一个游标，用于记录逆向遍历的位置  
56.       
57. public ProductIterator(ProductList list) {  
58. this.productList = list;  
59. this.products = list.getObjects(); //获取集合对象  
60. 0; //设置正向遍历游标的初始值  
61. 1; //设置逆向遍历游标的初始值  
62.     }  
63.       
64. public void next() {  
65. if(cursor1 < products.size()) {  
66.             cursor1++;  
67.         }  
68.     }  
69.       
70. public boolean isLast() {  
71. return (cursor1 == products.size());  
72.     }  
73.       
74. public void previous() {  
75. if (cursor2 > -1) {  
76.             cursor2--;  
77.         }  
78.     }  
79.       
80. public boolean isFirst() {  
81. return (cursor2 == -1);  
82.     }  
83.       
84. public Object getNextItem() {  
85. return products.get(cursor1);  
86.     }   
87.           
88. public Object getPreviousItem() {  
89. return products.get(cursor2);  
90.     }     
91. }  

       编写如下客户端测试代码：

[java]  ​​view plain​​ ​​copy​​

1. public class Client {  
2. public static void main(String args[]) {  
3. new ArrayList<String>();  
4. "倚天剑");  
5. "屠龙刀");  
6. "断肠草");  
7. "葵花宝典");  
8. "四十二章经");  
9.               
10.         AbstractObjectList list;  
11.         AbstractIterator iterator;  
12.           
13. new ProductList(products); //创建聚合对象  
14. //创建迭代器对象  
15.           
16. "正向遍历：");      
17. while(!iterator.isLast()) {  
18. "，");  
19.             iterator.next();  
20.         }  
21.         System.out.println();  
22. "-----------------------------");  
23. "逆向遍历：");  
24. while(!iterator.isFirst()) {  
25. "，");  
26.             iterator.previous();  
27.         }  
28.     }  
29. }  

       编译并运行程序，输出结果如下：

ProductList类更换一个迭代器，只需要增加一个新的具体迭代器类作为抽象迭代器类的子类，重新实现遍历方法，原有迭代器代码无须修改，也符合“开闭原则”；但是如果要在迭代器中增加新的方法，则需要修改抽象迭代器源代码，这将违背“开闭原则”。

4 使用内部类实现迭代器

       在迭代器模式结构图中，我们可以看到具体迭代器类和具体聚合类之间存在双重关系，其中一个关系为关联关系，在具体迭代器中需要维持一个对具体聚合对象的引用，该关联关系的目的是访问存储在聚合对象中的数据，以便迭代器能够对这些数据进行遍历操作。

       除了使用关联关系外，为了能够让迭代器可以访问到聚合对象中的数据，我们还可以将迭代器类设计为聚合类的内部类，JDK中的迭代器类就是通过这种方法来实现的，如下AbstractList类代码片段所示：

[java]  ​​view plain​​ ​​copy​​

1. package java.util;  
2. ……  
3. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {  
4.     ......  
5. private class Itr implements Iterator<E> {  
6. int cursor = 0;  
7.         ......  
8. }  
9. ……  
10. }  

我们可以通过类似的方法来设计第3节中的ProductList类，将ProductIterator类作为ProductList类的内部类，代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. //商品数据类：具体聚合类  
2. class ProductList extends AbstractObjectList {  
3. public ProductList(List products) {  
4. super(products);  
5.     }  
6.       
7. public AbstractIterator createIterator() {  
8. return new ProductIterator();  
9.     }  
10.       
11. //商品迭代器：具体迭代器，内部类实现  
12. private class ProductIterator implements AbstractIterator {  
13. private int cursor1;  
14. private int cursor2;  
15.           
16. public ProductIterator() {  
17. 0;  
18. 1;  
19.         }  
20.           
21. public void next() {  
22. if(cursor1 < objects.size()) {  
23.                 cursor1++;  
24.             }  
25.         }  
26.           
27. public boolean isLast() {  
28. return (cursor1 == objects.size());  
29.         }  
30.           
31. public void previous() {  
32. if(cursor2 > -1) {  
33.                 cursor2--;  
34.             }  
35.         }  
36.           
37. public boolean isFirst() {  
38. return (cursor2 == -1);  
39.         }  
40.           
41. public Object getNextItem() {  
42. return objects.get(cursor1);  
43.         }   
44.               
45. public Object getPreviousItem() {  
46. return objects.get(cursor2);  
47.         }     
48.     }  
49. }  

       无论使用哪种实现机制，客户端代码都是一样的，也就是说客户端无须关心具体迭代器对象的创建细节，只需通过调用工厂方法createIterator()即可得到一个可用的迭代器对象，这也是使用工厂方法模式的好处，通过工厂来封装对象的创建过程，简化了客户端的调用。

5 JDK内置迭代器

Java、C#等编程语言中都提供了内置迭代器。在Java集合框架中，常用的List和Set等聚合类都继承（或实现）了java.util.Collection接口，在Collection接口中声明了如下方法（部分）：

[java]  ​​view plain​​ ​​copy​​

1. package java.util;  
2.   
3. public interface Collection<E> extends Iterable<E> {  
4.     ……  
5. boolean add(Object c);  
6. boolean addAll(Collection c);  
7. boolean remove(Object o);  
8. boolean removeAll(Collection c);  
9. boolean remainAll(Collection c);   
10. Iterator iterator();  
11. ……  
12. }  

iterator()方法，用于返回一个Iterator迭代器对象，以便遍历聚合中的元素；具体的Java聚合类可以通过实现该iterator()方法返回一个具体的Iterator对象。

       JDK中定义了抽象迭代器接口Iterator，代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. package java.util;  
2.   
3. public interface Iterator<E> {  
4. boolean hasNext();  
5. E next();  
6. void remove();  
7. }  

hasNext()用于判断聚合对象中是否还存在下一个元素，为了不抛出异常，在每次调用next()之前需先调用hasNext()，如果有可供访问的元素，则返回true；next()方法用于将游标移至下一个元素，通过它可以逐个访问聚合中的元素，它返回游标所越过的那个元素的引用；remove()方法用于删除上次调用next()时所返回的元素。

       Java迭代器工作原理如图5所示，在第一个next()方法被调用时，迭代器游标由“元素1”与“元素2”之间移至“元素2”与“元素3”之间，跨越了“元素2”，因此next()方法将返回对“元素2”的引用；在第二个next()方法被调用时，迭代器由“元素2”与“元素3”之间移至“元素3”和“元素4”之间，next()方法将返回对“元素3”的引用，如果此时调用remove()方法，即可将“元素3”删除。

图5 Java迭代器示意图

如下代码片段可用于删除聚合对象中的第一个元素：

[java]  ​​view plain​​ ​​copy​​

1. Iterator iterator = collection.iterator();   //collection是已实例化的聚合对象  
2. iterator.next();        // 跳过第一个元素  
3. iterator.remove();  // 删除第一个元素  

next()方法与remove()方法的调用是相互关联的。如果调用remove()之前，没有先对next()进行调用，那么将会抛出一个IllegalStateException异常，因为没有任何可供删除的元素。​

     如下代码片段可用于删除两个相邻的元素：

[java]  ​​view plain​​ ​​copy​​

1. iterator.remove();  
2. iterator.next();  //如果删除此行代码程序将抛异常  
3. iterator.remove();    

在上面的代码片段中如果将代码iterator.next();去掉则程序运行抛异常，因为第二次删除时将找不到可供删除的元素。

JDK中，Collection接口和Iterator接口充当了迭代器模式的抽象层，分别对应于抽象聚合类和抽象迭代器，而Collection接口的子类充当了具体聚合类，下面以List为例加以说明，图6列出了JDK中部分与List有关的类及它们之间的关系：

图6 Java集合框架中部分类结构图

（注：为了简化类图，本图省略了大量方法）

JDK中，实际情况比图6要复杂很多，在图6中，List接口除了继承Collection接口的iterator()方法外，还增加了新的工厂方法listIterator()，专门用于创建ListIterator类型的迭代器，在List的子类LinkedList中实现了该方法，可用于创建具体的ListIterator子类ListItr的对象，代码如下所示：

[java]  ​​view plain​​ ​​copy​​

1. public ListIterator<E> listIterator(int index) {  
2. return new ListItr(index);  
3. }  

listIterator()方法用于返回具体迭代器ListItr类型的对象。在JDK源码中，AbstractList中的iterator()方法调用了listIterator()方法，如下代码所示：

[java]  ​​view plain​​ ​​copy​​

1. public Iterator<E> iterator() {  
2. return listIterator();  
3. }  

       客户端通过调用LinkedList类的iterator()方法，即可得到一个专门用于遍历LinkedList的迭代器对象。

      大家可能会问？既然有了iterator()方法，为什么还要提供一个listIterator()方法呢？这两个方法的功能不会存在重复吗？干嘛要多此一举？

      这是一个好问题，

。我给大家简单解释一下为什么要这样设计：由于在Iterator接口中定义的方法太少，只有三个，通过这三个方法只能实现正向遍历，而有时候我们需要对一个聚合对象进行逆向遍历等操作，因此在JDK的ListIterator接口中声明了用于逆向遍历的hasPrevious()和previous()等方法，如果客户端需要调用这两个方法来实现逆向遍历，就不能再使用iterator()方法来创建迭代器了，因为此时创建的迭代器对象是不具有这两个方法的。我们只能通过如下代码来创建ListIterator类型的迭代器对象：

[java]  ​​view plain​​ ​​copy​​

1. ListIterator i = c.listIterator();  

正因为如此，在JDK的List接口中不得不增加对listIterator()方法的声明，该方法可以返回一个ListIterator类型的迭代器，ListIterator迭代器具有更加强大的功能。

Java语言中，我们可以直接使用JDK内置的迭代器来遍历聚合对象中的元素，下面的代码演示了如何使用Java内置的迭代器：

[java]  ​​view plain​​ ​​copy​​

1. import java.util.*;  
2.   
3. public class IteratorDemo {  
4. public static void process(Collection c) {  
5. //创建迭代器对象  
6.           
7. //通过迭代器遍历聚合对象  
8. while(i.hasNext()) {  
9.             System.out.println(i.next().toString());  
10.         }  
11.    }  
12.   
13. public static void main(String args[]) {  
14.         Collection persons = new ArrayList(); //创建一个ArrayList类型的聚合对象  
15. "张无忌");  
16. "小龙女");  
17. "令狐冲");  
18. "韦小宝");  
19. "袁紫衣");  
20. "小龙女");  
21.           
22.         process(persons);  
23.     }  
24. }  

在静态方法process()中使用迭代器Iterator对Collection对象进行处理，该代码运行结果如下：

如果需要更换聚合类型，如将List改成Set，则只需更换具体聚合类类名，如将上述代码中的ArrayList改为HashSet，则输出结果如下：

在HashSet中合并了重复元素，并且元素以随机次序输出，其结果与使用ArrayList不相同。由此可见，通过使用迭代器模式，使得更换具体聚合类变得非常方便，而且还可以根据需要增加新的聚合类，新的聚合类只需要实现Collection接口，无须修改原有类库代码，符合“开闭原则”。

6 迭代器模式总结

      Java、C#等语言已定义好的迭代器即可，迭代器已经成为我们操作聚合对象的基本工具之一。

       1. 主要优点

       迭代器模式的主要优点如下：

       (1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。

       (2) 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。

       (3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

       2. 主要缺点

       迭代器模式的主要缺点如下：

       (1) 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

       (2) 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

       3. 适用场景

       在以下情况下可以考虑使用迭代器模式：

       (1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。

       (2) 需要为一个聚合对象提供多种遍历方式。

       (3) 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。