【行为型模式】迭代器模式

1、简介

迭代器模式(Iterator)是一种行为设计模式，它允许我们遍历一个复杂的集合对象而无需暴露其内部表示。它提供了一种统一的方式来访问一个聚合对象中的各个元素，而不用暴露该对象的内部结构。迭代器模式可以让我们在遍历过程中删除、添加或修改元素，而不会影响到迭代器的正确性。

有时候，对于某些复杂的对象，我们可能需要对其中的元素进行遍历操作，但是这个对象的内部结构比较复杂，我们不能直接通过索引来访问其中的元素。此时，就需要采用迭代器模式，通过提供一个迭代器来遍历该对象的元素，而无需了解该对象的内部实现细节。迭代器模式可以有效地隔离集合对象和遍历算法之间的耦合关系，使得两者可以独立变化，从而提高代码的可维护性和可扩展性。

2、结构

迭代器模式主要由以下几个结构组成：

1. 迭代器（Iterator）：定义访问和遍历聚合对象中元素的接口，包括获取下一个元素、判断是否还有下一个元素等方法。
2. 具体迭代器（Concrete Iterator）：实现迭代器接口，存储聚合对象的当前状态，负责遍历聚合对象中的元素。
3. 聚合对象（Aggregate）：定义创建相应迭代器对象的接口，一般是一个集合类，如列表、数组等。
4. 具体聚合对象（Concrete Aggregate）：实现聚合对象接口，创建具体迭代器对象，可以通过实现不同的聚合对象来提供不同方式的遍历。

在迭代器模式中，客户端通过获取聚合对象的迭代器，使用迭代器的方法遍历聚合对象中的元素，而无需暴露聚合对象的内部表示。这样可以提高系统的灵活性和可扩展性，同时也降低了聚合对象与迭代器之间的耦合度。

3、实现方式

3.1、案例引入

说到迭代器，大家应该很容易就想到在集合中的迭代器遍历集合的场景，这里我们就通过迭代器模式，自定义简单的集合和迭代器，模拟使用迭代器遍历集合的场景。

3.2、结构分析

在上述场景中，结构分别对应迭代器模式中的角色：

• MyList：对应迭代器模式中的抽象聚合类
• MyArrayList：对应迭代器模式中的具体的聚合类
• MyIterator：对应迭代器模式中的抽象迭代器类；
• ArrayListIterator：对应迭代器模式中的具体迭代器类；
• list.iterator()：返回的是实现了 Iterator 接口的具体迭代器对象。

3.3、具体实现

下面是使用迭代器模式自定义实现 MyList、MyArrayList、MyIterator 的具体代码：

MyList 接口表示抽象聚合角色：

public interface MyList<T> {
    /**
     * 添加元素到列表中。
     */
    void add(T item);

    /**
     * 返回一个新的迭代器对象。
     */
    MyIterator<T> iterator();
}

MyArrayList 类表示具体聚合角色：

public class MyArrayList<T> implements MyList<T> {
    private T[] data;
    private int size;

    public MyArrayList() {
        data = (T[]) new Object[10];
        size = 0;
    }

    @Override
    public void add(T item) {
        data[size] = item;
        size++;
    }

    @Override
    public MyIterator<T> iterator() {
        return new ArrayListIterator();
    }

    /**
     * 具体迭代器角色，用于遍历 MyArrayList 中的元素。
     */
    private class ArrayListIterator implements MyIterator<T> {
        private int index;

        public ArrayListIterator() {
            index = 0;
        }

        @Override
        public boolean hasNext() {
            return index < size;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new IllegalStateException("已经没有更多元素可供迭代");
            }

            T item = data[index];
            index++;
            return item;
        }
    }
}

MyIterator 接口表示抽象迭代器角色：

public interface MyIterator<T> {
    /**
     * 返回 true，如果还有更多的元素可以迭代。
     */
    boolean hasNext();

    /**
     * 返回下一个元素。
     */
    T next();
}

在示例中，我们创建了一个 MyArrayList 对象，并将一些元素添加到其中。然后，我们通过 for 循环使用 list.iterator() 方法返回具体迭代器对象来遍历列表中的所有元素，并打印每个元素的值。

public static void main(String[] args) {
    MyList<String> list = new MyArrayList<>();
    list.add("苹果");
    list.add("香蕉");
    list.add("橙子");

    // 使用具体迭代器对象遍历列表中的所有元素，并打印每个元素的值
    MyIterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

输出结果如下：

苹果
香蕉
橙子

4、迭代器模式优缺点

迭代器模式有以下优缺点:

优点：

1. 单一职责原则。 通过将体积庞大的遍历算法代码抽取为独立的类， 可对客户端代码和集合进行整理;
2. 开闭原则。 可实现新型的集合和迭代器并将其传递给现有代码， 无需修改现有代码;
3. 代码复用性好。由于迭代器模式将遍历集合的代码封装到迭代器中，因此我们可以将同样的迭代器应用于不同的集合对象，从而减少了重复的代码;
4. 可以并行遍历同一集合， 因为每个迭代器对象都包含其自身的遍历状态。

缺点：

1. 使用迭代器模式会增加一个额外的类，从而增加复杂度，使得代码变得更加难以理解;
2. 如果遍历的过程中需要对集合对象进行修改，那么就需要同时维护迭代器和集合对象之间的状态，这可能会导致迭代器模式的实现变得复杂;
3. 在某些语言中，由于没有内置迭代器的支持，因此需要手动实现迭代器模式，这会增加开发和维护的复杂度。

优点	缺点
符合单一职责原则	类数量增加
符合开闭原则	额外维护迭代器和集合对象之间的状态
代码复用性好	增加开发和维护的复杂度
支持并行遍历

5、应用场景

迭代器模式可以应用于以下场景：

1. 在遍历集合元素时，不希望暴露集合内部的表示方式和数据结构，而是希望通过统一的接口进行操作。 迭代器模式使得我们可以将遍历行为封装在迭代器对象中，并把迭代器对象作为集合类的成员，从而达到这个目的；
2. 当需要支持多种遍历方式时，可以使用迭代器模式。例如，在一个列表中，需要实现从前向后和从后向前两种遍历方式，使用迭代器模式非常方便地实现这样的需求；
3. 需要提供一种通用的遍历机制，使得不同类型的集合对象都可以被遍历。由于迭代器模式将遍历过程封装在迭代器中，因此我们可以为每一种集合对象都提供一个对应的迭代器；
4. 当需要对集合对象进行复杂的遍历操作时，可以使用迭代器模式。例如，有些集合对象可能需要在遍历过程中进行筛选、排序等处理，这些逻辑可以在迭代器中完成，从而使得客户端代码保持简洁。