场景

为开发一套销售管理系统，在对该系统进行分析和设计时，发现经常需要对系统中的商品数据、客户数据等进行遍历，

为了复用这些遍历代码，开发人员设计了一个抽象的数据集合类AbstractObjectList，而将存储商品和客户等数据的类

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

在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；

二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。

因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，

由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

迭代器模式

迭代器模式(Iterator Pattern)：

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

迭代器模式是一种对象行为型模式

迭代器模式结构图

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

Iterator（抽象迭代器）：

它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，

例如：

用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，

用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

ConcreteIterator（具体迭代器）：

它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，

在具体实现时，游标通常是一个表示位置的非负整数。

Aggregate（抽象聚合类）：

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

ConcreteAggregate（具体聚合类）：

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

注：

博客：
霸道流氓气质_C#,架构之路,SpringBoot-CSDN博客

实现

1、新建抽象聚合类

import java.util.ArrayList;
import java.util.List;

//在本例中，为了详细说明自定义迭代器的实现过程，没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历
//抽象聚合类
abstract class AbstractObjectList {
    protected List<Object> objects = new ArrayList<>();

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

2、新建抽象迭代器

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

3、新建具体聚合类:商品数据类

import java.util.List;

//商品数据类：具体聚合类
public class ProductList extends AbstractObjectList{

    public ProductList(List objects) {
        super(objects);
    }

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

4、新建具体迭代器:商品迭代器

import java.util.List;

//商品迭代器:具体迭代器
public 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);
    }
}

5、客户端调用

import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        List products = new ArrayList();
        products.add("商品1");
        products.add("商品2");
        products.add("商品3");
        products.add("商品4");

        AbstractObjectList list;
        AbstractIterator iterator;

        list = new ProductList(products);//创建聚合对象
        iterator = list.createIterator();//创建迭代器对象

        System.out.println("正向遍历");
        while (!iterator.isLast()){
            System.out.println(iterator.getNextItem()+",");
            iterator.next();
        }
        System.out.println("逆向遍历");
        while (!iterator.isFirst()){
            System.out.println(iterator.getPreviousItem()+",");
            iterator.previous();
        }
    }
}

6、总结

迭代器模式是一种使用频率非常高的设计模式，通过引入迭代器可以将数据的遍历功能从聚合对象中分离出来，

聚合对象只负责存储数据，而遍历数据由迭代器来完成。由于很多编程语言的类库都已经实现了迭代器模式，

因此在实际开发中，我们只需要直接使用Java、C#等语言已定义好的迭代器即可，迭代器已经成为我们操作

聚合对象的基本工具之一。

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

(1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中

只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类

以支持新的遍历方式。

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

这样可以简化聚合类的设计。

(3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，