18.迭代器模式(行为型)

迭代器模式(行为型)

原书链接java设计模式(刘伟)

一、相关概念

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

1). 定义

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

---

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

2). 相关角色

1. Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
2. ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
3. Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
4. ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

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

3). 典型代码

1. 迭代器

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() { ...... }
}

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

2. 聚合类

interface Aggregate {
    Iterator createIterator();
}

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

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

二、案例需求举例

1). 需求描述

Sunny软件公司为某商场开发了一套销售管理系统，在对该系统进行分析和设计时，Sunny软件公司开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历，为了复用这些遍历，请使用迭代器模式进行设计。

2). 类图设计

---

本实例中为了演示迭代器模式，没有使用JDK内置的迭代器工具。

3). 代码实现

1. 抽象聚合类

/**
 * 抽象聚合类
 */
abstract class AbstractObjectList<E> {

    protected List<E> objects = new ArrayList<E>();

    public AbstractObjectList(List<E> objects) {
        this.objects = objects;
    }

    public void addObject(E obj) {
        this.objects.add(obj);
    }

    public void removeObject(E obj) {
        this.objects.remove(obj);
    }

    public List<E> getObjects() {
        return this.objects;
    }

    //声明创建迭代器对象的抽象工厂方法
    public abstract AbstractIterator createIterator();
}

2. 抽象迭代器

/**
 * 抽象迭代器
 */
interface AbstractIterator {
    public void next(); // 移至下一个元素
    public boolean isLast(); // 判断是否为最后一个元素
    public void previous(); // 移至上一个元素
    public boolean isFirst(); // 判断是否为第一个元素
    public Object getNextItem(); // 获取下一个元素
    public Object getPreviousItem(); // 获取上一个元素
}

3. 具体聚合类与具体迭代器的实现

/**
 * 商品数据类：具体聚合类
 */
class ProductList<E> extends AbstractObjectList<E> {

    public ProductList(List<E> products) {
        super(products);
    }

    //实现创建迭代器对象的具体工厂方法
    public AbstractIterator createIterator() {
        return new ProductIterator(this);
    }

    /**
     * 商品迭代器：具体迭代器 使用内部类的方式实现
     */
    private class ProductIterator implements AbstractIterator {
        private ProductList<E> productList;
        private List<E> products;
        private int cursor1; // 定义一个游标，用于记录正向遍历的位置
        private int cursor2; // 定义一个游标，用于记录逆向遍历的位置

        public ProductIterator(ProductList<E> 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);
        }
    }
}

4. 客户端测试类

/**
 * @author Liucheng
 * @since 2019-09-05
 */
public class Client {

    public static void main(String[] args) {

        List<String> products = new ArrayList<>();
        products.add("倚天剑");
        products.add("屠龙刀");
        products.add("断肠草");
        products.add("葵花宝典");
        products.add("四十二章经");

        AbstractObjectList<String> list = new ProductList<String>(products); //创建聚合对象
        AbstractIterator 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();
        }
    }
}

三、拓展-JDK内置迭代器简单介绍

1). 内置接口

在Java集合框架中，常用的List和Set等聚合类都继承（或实现）了java.util.Collection接口, 而Collection 接口继承了Iterable接口。

package java.util;
public interface Collection<E> extends Iterable<E> {
    ……
    boolean add(Object c);
    boolean addAll(Collection c);
    boolean remove(Object o);
    boolean removeAll(Collection c);
    boolean remainAll(Collection c);
    Iterator iterator();
    ……
}

除了包含一些增加元素和删除元素的方法外，还提供了一个iterator()方法，用于返回一个Iterator迭代器对象，以便遍历聚合中的元素；具体的Java聚合类可以通过实现该iterator()方法返回一个具体的Iterator对象。

package java.util;
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

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

2). 原理

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

---

四、总结

1). 优点

1. 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
2. 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
3. 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

2). 缺点

1. 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
2. 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

3). 适用场景

1. 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
2. 需要为一个聚合对象提供多种遍历方式。
3. 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。