设计模式之迭代器模式

概念

想象你有一台电视，里面有100个电视频道（存储在一个列表中）。你想逐个浏览这些频道，找到想看的节目。这时，遥控器的“下一个频道”和“上一个频道”按钮，就是一个典型的 “迭代器”！你不需要知道电视内部如何存储频道（数组、链表？不重要！）。你只需要按遥控器的按钮，就能顺序访问所有频道，甚至随时反向遍历。

定义

迭代器模式是一种行为型设计模式，它提供了一种顺序访问一个聚合对象中各个元素的方法，而又不暴露该对象的内部表示。简单来说，就是让你能够按照一定顺序逐个访问集合中的元素，而不需要了解集合是如何存储和组织这些元素的。

结构组成

• 迭代器（Iterator）：定义了访问和遍历元素的接口，一般包含诸如next（获取下一个元素）、hasNext（判断是否还有下一个元素）等方法。
• 具体迭代器（Concrete Iterator）：实现了迭代器接口，负责跟踪遍历的当前位置，知道如何访问聚合中的元素，通常会持有一个指向聚合对象的引用，以便能够访问其中的元素。
• 聚合（Aggregate）：定义了创建迭代器对象的接口，比如createIterator方法，该方法用于创建一个能够遍历其元素的迭代器。
• 具体聚合（Concrete Aggregate）：实现了聚合接口，它是实际存储元素的容器，比如列表、树、图等数据结构，同时负责创建具体的迭代器对象，为迭代器提供数据。

工作原理

迭代器模式将元素的遍历行为从聚合对象中分离出来，封装在迭代器对象中。这样，聚合对象只负责存储元素，而迭代器对象负责遍历元素。通过这种方式，迭代器模式提高了代码的可维护性和可扩展性，使得聚合对象的内部结构可以独立于遍历算法进行变化。同时，它也提供了一种统一的遍历接口，使得客户端可以以相同的方式处理不同类型的聚合对象。

工作流程

1. 创建聚合对象：首先，客户端代码创建一个具体聚合对象，该对象包含一组元素，这些元素可以是任何类型的数据集合，如数组、列表等。
2. 创建迭代器对象：客户端通过调用具体聚合对象的创建迭代器方法，获取一个具体迭代器对象。这个迭代器对象与该聚合对象相关联，并且知道如何遍历该聚合对象中的元素。
3. 遍历元素：客户端使用迭代器对象提供的接口来遍历聚合对象中的元素。通常，迭代器提供了两个基本方法：
   • hasNext()：用于判断聚合对象中是否还有下一个元素。
   • next()：用于返回聚合对象中的下一个元素，并将迭代器的位置移动到下一个元素。
   • 客户端通过循环调用这两个方法，直到hasNext()返回false，表示已经遍历完所有元素。
4. 隐藏内部表示：在整个遍历过程中，客户端只需要与迭代器对象进行交互，而不需要了解聚合对象的内部结构。具体聚合对象可以自由地改变其内部表示，只要迭代器能够正确地遍历元素，客户端代码就不需要做任何修改。

示例

类图

C++实现

#include <iostream>
#include <vector>

// 前向声明
class TVChannelIterator;

// 频道类
class TVChannel {
private:
    int channelNumber;
public:
    explicit TVChannel(int number) : channelNumber(number) {}

    [[nodiscard]] int getChannelNumber() const {
        return channelNumber;
    }
};

// 聚合接口
class TVChannelCollection {
public:
    virtual TVChannelIterator* createIterator() = 0;
    [[nodiscard]] virtual int getChannelCount() const = 0;
    [[nodiscard]] virtual TVChannel getChannel(int index) const = 0;
    virtual ~TVChannelCollection() = default;
};

// 迭代器接口
class TVChannelIterator {
public:
    [[nodiscard]] virtual bool hasNext() const = 0;
    virtual TVChannel next() = 0;
    virtual ~TVChannelIterator() = default;
};

// 具体聚合类：电视机
class Television : public TVChannelCollection {
private:
    std::vector<TVChannel> channels;
public:
    void addChannel(const TVChannel& channel) {
        channels.push_back(channel);
    }

    TVChannelIterator* createIterator() override;

    [[nodiscard]] int getChannelCount() const override {
        return channels.size();
    }

    [[nodiscard]] TVChannel getChannel(int index) const override {
        return channels[index];
    }
};

// 具体迭代器类
class TelevisionIterator : public TVChannelIterator {
private:
    const Television& tv;
    int currentIndex;
public:
    explicit TelevisionIterator(const Television& television) : tv(television), currentIndex(0) {}

    [[nodiscard]] bool hasNext() const override {
        return currentIndex < tv.getChannelCount();
    }

    TVChannel next() override {
        return tv.getChannel(currentIndex++);
    }
};

// 实现电视机的 createIterator 方法
TVChannelIterator* Television::createIterator() {
    return new TelevisionIterator(*this);
}

// 客户端代码
int main() {
    Television tv;
    tv.addChannel(TVChannel(1));
    tv.addChannel(TVChannel(2));
    tv.addChannel(TVChannel(3));

    TVChannelIterator* iterator = tv.createIterator();
    while (iterator->hasNext()) {
        TVChannel channel = iterator->next();
        std::cout << "Channel number: " << channel.getChannelNumber() << std::endl;
    }

    delete iterator;
    return 0;
}

Java实现

// 频道类
class TVChannel {
    private int channelNumber;

    public TVChannel(int channelNumber) {
        this.channelNumber = channelNumber;
    }

    public int getChannelNumber() {
        return channelNumber;
    }
}

// 迭代器接口
interface TVChannelIterator {
    boolean hasNext();
    TVChannel next();
}

// 聚合接口
interface TVChannelCollection {
    TVChannelIterator createIterator();
}

// 具体聚合类：电视机
class Television implements TVChannelCollection {
    private java.util.ArrayList<TVChannel> channels = new java.util.ArrayList<>();

    public void addChannel(TVChannel channel) {
        channels.add(channel);
    }

    @Override
    public TVChannelIterator createIterator() {
        return new TelevisionIterator(this);
    }

    public int getChannelCount() {
        return channels.size();
    }

    public TVChannel getChannel(int index) {
        return channels.get(index);
    }
}

// 具体迭代器类
class TelevisionIterator implements TVChannelIterator {
    private Television tv;
    private int currentIndex = 0;

    public TelevisionIterator(Television tv) {
        this.tv = tv;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < tv.getChannelCount();
    }

    @Override
    public TVChannel next() {
        return tv.getChannel(currentIndex++);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Television tv = new Television();
        tv.addChannel(new TVChannel(1));
        tv.addChannel(new TVChannel(2));
        tv.addChannel(new TVChannel(3));

        TVChannelIterator iterator = tv.createIterator();
        while (iterator.hasNext()) {
            TVChannel channel = iterator.next();
            System.out.println("Channel number: " + channel.getChannelNumber());
        }
    }
}

代码说明：

1. TVChannel 类：表示一个电视频道，包含一个频道编号。
2. TVChannelCollection 接口：定义了创建迭代器、获取频道数量和获取指定索引频道的方法。
3. TVChannelIterator 接口：定义了迭代器的基本操作，包括判断是否还有下一个频道和获取下一个频道。
4. Television 类：具体聚合类，代表电视机，使用std::vector存储频道。它实现了TVChannelCollection接口的方法，并提供了添加频道的方法。
5. TelevisionIterator 类：具体迭代器类，负责遍历电视机中的频道。它实现了TVChannelIterator接口的方法。
6. main 函数：客户端代码，创建电视机对象，添加频道，创建迭代器并遍历所有频道。

迭代器模式的优缺点

优点

1. 简化聚合对象的接口

迭代器模式将遍历逻辑从聚合对象中分离出来，使得聚合对象只需要关注元素的存储，而不需要提供复杂的遍历方法。这样可以简化聚合对象的接口，使其职责更加单一，符合单一职责原则。例如，在一个包含大量数据的列表类中，如果不使用迭代器模式，可能需要在列表类中添加各种遍历相关的方法，这会使列表类变得复杂且难以维护。使用迭代器模式后，列表类只需要提供创建迭代器的方法，遍历逻辑由迭代器类负责。

2. 支持多种遍历方式

可以为一个聚合对象创建多个不同的迭代器，每个迭代器可以实现不同的遍历算法。例如，对于一个树形结构的聚合对象，可以创建深度优先遍历迭代器和广度优先遍历迭代器，客户端可以根据需要选择不同的迭代器进行遍历，提高了代码的灵活性和可扩展性。

3. 提高代码的可维护性和可复用性

迭代器模式将遍历逻辑封装在迭代器类中，当需要修改遍历算法时，只需要修改迭代器类的实现，而不会影响到聚合对象和客户端代码。同时，迭代器类可以在不同的聚合对象之间复用，只要这些聚合对象的元素类型和存储结构兼容。

4. 隐藏聚合对象的内部实现

客户端只需要与迭代器对象进行交互，而不需要了解聚合对象的内部结构。聚合对象可以自由地改变其内部表示，只要迭代器能够正确地遍历元素，客户端代码就不需要做任何修改。这提高了代码的安全性和可维护性。

5. 方便并行遍历

在多线程环境下，可以为每个线程创建独立的迭代器，实现对聚合对象的并行遍历，提高程序的性能。

缺点

1. 增加类的数量

使用迭代器模式会引入额外的迭代器类，这会增加系统中类的数量，使代码结构变得复杂。特别是在处理简单的聚合对象时，使用迭代器模式可能会显得过于繁琐。

2. 对小型聚合对象不友好

对于简单的、元素数量较少的聚合对象，使用迭代器模式可能会增加代码的复杂度，而收益并不明显。因为创建和管理迭代器对象也需要一定的开销，在这种情况下，直接使用简单的循环遍历可能更加高效和简洁。

3. 维护迭代器状态的复杂性

当迭代器需要维护复杂的状态时，如支持撤销操作或跳过某些元素，迭代器的实现会变得复杂，增加了开发和维护的难度。

4. 降低了直接访问元素的效率

使用迭代器访问元素需要通过迭代器的接口方法，相比于直接访问数组或列表中的元素，会有一定的性能开销。特别是在对性能要求极高的场景下，这种开销可能会成为瓶颈。

注意事项

设计与实现层面

1. 类数量的增加

• 迭代器模式会引入额外的迭代器类和相关接口，这会增加系统中类的数量，使代码结构变得复杂。在项目规模较小或者聚合对象简单时，使用迭代器模式可能会导致代码过度设计。因此，需要根据实际情况权衡是否使用该模式，对于简单的聚合对象，直接使用循环遍历可能更加简洁高效。

2. 迭代器状态管理

• 迭代器需要维护自身的状态，例如当前遍历的位置。在实现迭代器时，要确保状态的正确更新和管理。如果状态管理不当，可能会导致遍历出错，如跳过元素、重复访问元素等问题。例如，在多线程环境下，多个线程同时使用同一个迭代器可能会导致状态混乱，需要进行同步处理。

3. 迭代器的兼容性

• 当聚合对象的内部结构发生变化时，可能需要相应地修改迭代器的实现，以确保迭代器能够正确遍历新的结构。例如，如果聚合对象从数组存储改为链表存储，迭代器的遍历逻辑可能需要进行调整。因此，在设计迭代器时，要考虑到聚合对象未来可能的变化，尽量使迭代器具有一定的通用性和可扩展性。

4. 性能开销

• 使用迭代器访问元素需要通过迭代器的接口方法，相比于直接访问数组或列表中的元素，会有一定的性能开销。特别是在对性能要求极高的场景下，这种开销可能会成为瓶颈。因此，在性能敏感的场景中，需要谨慎使用迭代器模式，或者对迭代器的实现进行优化。

使用与维护层面

5. 并发访问问题

• 在多线程环境下，多个线程同时访问同一个迭代器或者聚合对象可能会导致数据不一致或其他并发问题。例如，一个线程正在使用迭代器遍历聚合对象，而另一个线程同时修改了聚合对象的结构（如添加或删除元素），这可能会使迭代器的状态变得无效，导致ConcurrentModificationException等异常。为了避免这种情况，可以采用同步机制或者使用线程安全的迭代器。

6. 迭代器的生命周期管理

• 迭代器通常依赖于聚合对象，如果聚合对象在迭代器使用过程中被销毁或者回收，迭代器可能会失效。因此，要确保迭代器的生命周期与聚合对象的生命周期相匹配，避免出现悬空引用的问题。

7. 迭代器的遍历顺序

• 不同的迭代器可能实现不同的遍历顺序，如顺序遍历、逆序遍历、随机遍历等。在使用迭代器时，要清楚其遍历顺序，以免产生误解。同时，在设计迭代器时，要明确指定其遍历顺序，并在文档中进行说明。

8. 迭代器的重置问题

• 有些场景下可能需要对迭代器进行重置，使其重新从起始位置开始遍历。在设计迭代器时，需要考虑是否提供重置方法，以及如何实现重置逻辑，确保重置后迭代器能够正确工作。

应用场景

数据集合处理

• 统一遍历方式：当面对多种不同类型的数据集合，如数组、链表、树、图等，迭代器模式能提供统一的遍历接口。这使得开发者无需关心集合的具体实现细节，只需要使用迭代器提供的方法进行遍历操作即可，提高了代码的可复用性和可维护性。
• 复杂数据结构遍历：对于一些复杂的数据结构，如多层嵌套的集合或者自定义的数据结构，其内部的遍历逻辑可能非常复杂。迭代器模式可以将这些复杂的遍历逻辑封装在迭代器中，对外提供简单的遍历接口，降低了客户端代码的复杂度。

数据库操作

• 结果集遍历：在数据库编程中，执行查询操作后会返回一个结果集，这个结果集可能包含大量的数据。使用迭代器模式可以逐行遍历结果集，避免一次性将所有数据加载到内存中，从而减少内存的占用。数据库中的游标概念本质上就是迭代器模式的应用。
• 分批次处理数据：当需要对数据库中的大量数据进行分批次处理时，迭代器模式可以实现每次只处理一部分数据，处理完后再加载下一部分数据，这样可以有效控制内存使用和提高处理效率。

文件处理

• 不同格式文件遍历：在处理各种不同格式的文件时，如文本文件、CSV 文件、XML 文件等，迭代器模式可以为每种文件格式提供统一的遍历方式。通过迭代器，开发者可以按行、按记录或者按节点等方式遍历文件内容，而无需关心文件的具体格式和解析细节。
• 大文件处理：对于大文件，由于无法一次性将其全部加载到内存中，使用迭代器模式可以逐块读取文件内容，进行分阶段处理，避免内存溢出问题。

游戏开发

• 游戏元素管理：在游戏场景中，通常会包含大量的游戏元素，如角色、道具、障碍物等。迭代器模式可以方便地遍历这些游戏元素，进行更新、渲染、碰撞检测等操作。开发者可以根据不同的需求创建不同的迭代器，实现对游戏元素的不同遍历方式。
• 关卡数据遍历：游戏中的关卡数据可能包含多个层次和不同类型的信息，如地图布局、敌人分布、道具位置等。使用迭代器模式可以方便地遍历这些关卡数据，进行关卡的初始化、更新和管理。

多线程与并发编程

• 安全的并发遍历：在多线程环境下，多个线程可能需要同时访问和遍历同一个数据集合。迭代器模式可以通过提供线程安全的迭代器实现，确保在并发访问时数据的一致性和安全性。每个线程可以拥有自己独立的迭代器，互不干扰地进行遍历操作。