AJohn Blog

外观

20. 迭代器模式

约 1169 字大约 4 分钟

2026-03-18

定义

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

人话：迭代器模式就像公交车上的售票员查票的过程。公交车上坐着很多乘客，比如“大鸟”“小菜”“老外”等，这些乘客都被放在公交车这个“集合”里。

如果不用迭代器模式来设计，程序里可能就要直接操作这个集合，比如用下标一个个访问乘客，还要自己去控制从第几个开始、什么时候结束、有没有越界等等。这样不仅麻烦，而且一旦集合结构发生变化（比如从数组换成链表），遍历代码也要跟着改，这在软件中就属于遍历逻辑与集合结构耦合过高。

而使用迭代器模式之后，就相当于安排了一位“售票员”。公交车本身只负责存放乘客，而“售票员”负责按顺序一个一个去询问乘客有没有买票。售票员知道如何从第一个乘客开始、如何走到下一个、以及什么时候走到最后。

这样一来，客户端代码就不需要关心公交车内部是怎么存储乘客的，也不用自己写循环控制逻辑，只需要让“售票员”去遍历即可，比如不断调用“下一个”，直到结束。

在软件中也是一样：迭代器模式把“如何遍历集合”这件事单独封装起来，让我们可以用统一的方式访问集合中的元素，而不需要暴露集合的内部结构，从而让代码更加清晰、解耦、易于扩展。

PlantUML Diagram

迭代器模式（Iterator）结构图

Iterator类——抽象迭代器：

// Iterator（抽象迭代器）
abstract class Iterator
{
    public abstract object First();        // 第一个元素
    public abstract object Next();         // 下一个元素
    public abstract bool IsDone();         // 是否遍历结束
    public abstract object CurrentItem();  // 当前元素
}

Aggregate类——抽象聚集：

// Aggregate（抽象聚集）
abstract class Aggregate
{
    public abstract Iterator CreateIterator();
}

ConcreteIterator类——具体迭代器：

// ConcreteIterator（具体迭代器）
class ConcreteIterator : Iterator
{
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate aggregate)
    {
        this.aggregate = aggregate;
    }

    public override object First()
    {
        return aggregate[0];
    }

    public override object Next()
    {
        object ret = null;
        current++;

        if (current < aggregate.Count)
        {
            ret = aggregate[current];
        }

        return ret;
    }

    public override bool IsDone()
    {
        return current >= aggregate.Count;
    }

    public override object CurrentItem()
    {
        return aggregate[current];
    }
}

ConcreteAggregate类——具体聚集：

// ConcreteAggregate（具体聚集）
class ConcreteAggregate : Aggregate
{
    private IList<object> items = new List<object>();

    public override Iterator CreateIterator()
    {
        return new ConcreteIterator(this);
    }

    public int Count
    {
        get { return items.Count; }
    }

    // 索引器
    public object this[int index]
    {
        get { return items[index]; }
        set { items.Insert(index, value); }
    }
}

客户端代码：

static void Main(string[] args)
{
    // 公交车（聚集对象）
    ConcreteAggregate a = new ConcreteAggregate();

    // 上车的乘客
    a[0] = "大鸟";
    a[1] = "小菜";
    a[2] = "行李";
    a[3] = "老外";
    a[4] = "公交内部员工";
    a[5] = "小偷";

    // 售票员（迭代器）
    Iterator i = new ConcreteIterator(a);

    object item = i.First();

    while (!i.IsDone())
    {
        Console.WriteLine($"{i.CurrentItem()} 请买车票！");
        i.Next();
    }

    Console.Read();
}

运行结果：

大鸟 请买车票！
小菜 请买车票！
行李 请买车票！
老外 请买车票！
公交内部员工 请买车票！
小偷 请买车票！

  • 为什么要用具体的迭代器Concretelterator来实现抽象的Iterator呢？直接访问ConcreteIterator不是更好吗？因为有一个好处，当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式，事实上，我们可以按照需要定制任何规则来遍历。

  • 迭代器（Iterator）模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

  • 迭代器模式在访问数组、集合、列表等数据时，尤其是数据库数据操作时，是非常普遍的应用，但由于它太普遍了，所以各种高级语言都对它进行了封装，所以反而给人感觉此模式本身不太常用了。