行为型模式之遍历聚合对象中的元素（迭代器模式）

完整解决方案

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

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

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

在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器：

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

迭代器模式总结

迭代器模式是一种使用频率非常高的设计模式，通过引入迭代器可以将数据的遍历功能从聚合对象中分离出来，聚合对象只负责存储数据，而遍历数据由迭代器来完成。由于很多编程语言的类库都已经实现了迭代器模式，因此在实际开发中，我们只需要直接使用Java、C#等语言已定义好的迭代器即可，迭代器已经成为我们操作聚合对象的基本工具之一。

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

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

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

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

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

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

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

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

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

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

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