迭代器模式(一)（遍历对象元素）

 文章摘抄至 http://blog.csdn.net/lovelion/article/details/9992005

 

     20世纪80年代，那时我家有一台“古老的”电视机，牌子我忘了，只记得是台黑白电视机，没有遥控器，每次开关机或者换台都需要通过电视机上面的那些按钮来完成，我印象最深的是那个用来换台的按钮，需要亲自用手去旋转（还要使点劲才能拧动），每转一下就“啪”的响一声，如果没有收到任何电视频道就会出现一片让人眼花的雪花点。当然，电视机上面那两根可以前后左右移动，并能够变长变短的天线也是当年电视机的标志性部件之一，我记得小时候每次画电视机时一定要画那两根天线，要不总觉得不是电视机，。随着科技的飞速发展，越来越高级的电视机相继出现，那种古老的电视机已经很少能够看到了。与那时的电视机相比，现今的电视机给我们带来的最大便利之一就是增加了电视机遥控器，我们在进行开机、关机、换台、改变音量等操作时都无须直接操作电视机，可以通过遥控器来间接实现。我们可以将电视机看成一个存储电视频道的集合对象，通过遥控器可以对电视机中的电视频道集合进行操作，如返回上一个频道、跳转到下一个频道或者跳转至指定的频道。遥控器为我们操作电视频道带来很大的方便，用户并不需要知道这些频道到底如何存储在电视机中。电视机遥控器和电视机示意图如图1所示：

 

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

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

 

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

       Sunny软件公司为某商场开发了一套销售管理系统，在对该系统进行分析和设计时，Sunny软件公司开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历，为了复用这些遍历代码，Sunny公司开发人员设计了一个抽象的数据集合类AbstractObjectList，而将存储商品和客户等数据的类作为其子类，AbstractObjectList类结构如图2所示：

图2  AbstractObjectList类结构图

       在图2中，List类型的对象objects用于存储数据，方法说明如表1所示：

表1  AbstractObjectList类方法说明

方法名

方法说明

AbstractObjectList()

构造方法，用于给objects对象赋值

addObject()

增加元素

removeObject()

删除元素

getObjects()

获取所有元素

next()

移至下一个元素

isLast()

判断当前元素是否是最后一个元素

previous()

移至上一个元素

isFirst()

判断当前元素是否是第一个元素

getNextItem()

获取下一个元素

getPreviousItem()

获取上一个元素

       AbstractObjectList类的子类ProductList和CustomerList分别用于存储商品数据和客户数据。

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

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

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

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

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

---

 

2 迭代器模式概述

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

       迭代器模式定义如下：

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

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

图3 迭代器模式结构图

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

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

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

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

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

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

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

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

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

 

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

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

 

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

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

interface Aggregate {Iterator createIterator();}

 

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

class ConcreteAggregate implements Aggregate {    ......    public Iterator createIterator() {return new ConcreteIterator(this);    }......}

 

---

 

3 完整解决方案

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

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

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

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

//在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历import java.util.*;//抽象聚合类abstract class AbstractObjectList {protected List<Object> objects = new ArrayList<Object>();public AbstractObjectList(List objects) {this.objects = objects;}public void addObject(Object obj) {this.objects.add(obj);}public void removeObject(Object obj) {this.objects.remove(obj);}public List getObjects() {return this.objects;}    //声明创建迭代器对象的抽象工厂方法public abstract AbstractIterator createIterator();}//商品数据类：具体聚合类class ProductList extends AbstractObjectList {public ProductList(List products) {super(products);}    //实现创建迭代器对象的具体工厂方法public AbstractIterator createIterator() {return new ProductIterator(this);}} //抽象迭代器interface AbstractIterator {public void next(); //移至下一个元素public boolean isLast(); //判断是否为最后一个元素public void previous(); //移至上一个元素public boolean isFirst(); //判断是否为第一个元素public Object getNextItem(); //获取下一个元素public Object getPreviousItem(); //获取上一个元素}//商品迭代器：具体迭代器class ProductIterator implements AbstractIterator {private ProductList productList;private List products;private int cursor1; //定义一个游标，用于记录正向遍历的位置private int cursor2; //定义一个游标，用于记录逆向遍历的位置public ProductIterator(ProductList list) {this.productList = list;this.products = list.getObjects(); //获取集合对象cursor1 = 0; //设置正向遍历游标的初始值cursor2 = products.size() -1; //设置逆向遍历游标的初始值}public void next() {if(cursor1 < products.size()) {cursor1++;}}public boolean isLast() {return (cursor1 == products.size());}public void previous() {if (cursor2 > -1) {cursor2--;}}public boolean isFirst() {return (cursor2 == -1);}public Object getNextItem() {return products.get(cursor1);} public Object getPreviousItem() {return products.get(cursor2);} }

 

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

class Client {public static void main(String args[]) {List products = new ArrayList();products.add("倚天剑");products.add("屠龙刀");products.add("断肠草");products.add("葵花宝典");products.add("四十二章经");AbstractObjectList list;AbstractIterator iterator;list = new ProductList(products); //创建聚合对象iterator = list.createIterator();//创建迭代器对象System.out.println("正向遍历：");while(!iterator.isLast()) {System.out.print(iterator.getNextItem() + "，");iterator.next();}System.out.println();System.out.println("-----------------------------");System.out.println("逆向遍历：");while(!iterator.isFirst()) {System.out.print(iterator.getPreviousItem() + "，");iterator.previous();}}}

 

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

正向遍历：

倚天剑，屠龙刀，断肠草，葵花宝典，四十二章经，

-----------------------------

逆向遍历：

四十二章经，葵花宝典，断肠草，屠龙刀，倚天剑，

       如果需要增加一个新的具体聚合类，如客户数据集合类，并且需要为客户数据集合类提供不同于商品数据集合类的正向遍历和逆向遍历操作，只需增加一个新的聚合子类和一个新的具体迭代器类即可，原有类库代码无须修改，符合“开闭原则”；如果需要为ProductList类更换一个迭代器，只需要增加一个新的具体迭代器类作为抽象迭代器类的子类，重新实现遍历方法，原有迭代器代码无须修改，也符合“开闭原则”；但是如果要在迭代器中增加新的方法，则需要修改抽象迭代器源代码，这将违背“开闭原则”。

 

---

 

4 使用内部类实现迭代器

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

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

package java.util;……public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {    ......    private class Itr implements Iterator<E> {    int cursor = 0;        ......}……}

 

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

//商品数据类：具体聚合类class ProductList extends AbstractObjectList {public ProductList(List products) {super(products);}public AbstractIterator createIterator() {return new ProductIterator();}//商品迭代器：具体迭代器，内部类实现private class ProductIterator implements AbstractIterator {private int cursor1;private int cursor2;public ProductIterator() {cursor1 = 0;cursor2 = objects.size() -1;}public void next() {if(cursor1 < objects.size()) {cursor1++;}}public boolean isLast() {return (cursor1 == objects.size());}public void previous() {if(cursor2 > -1) {cursor2--;}}public boolean isFirst() {return (cursor2 == -1);}public Object getNextItem() {return objects.get(cursor1);} public Object getPreviousItem() {return objects.get(cursor2);} }}

 

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