设计模式 <行为型> | 迭代器模式

迭代器模式(Iterator Pattern)

迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。集合对象也可以叫容器、聚合对象。

结构图：

角色：

1. 迭代器(Iterator)：声明遍历集合所需的一系列操作。
2. 具体迭代器(Concrete Iterators)：实现迭代器申明的所有接口。
3. 集合(Collection)：声明一个或多个方法来获取与集合兼容的迭代器。
4. 具体集合(Concrete Collections)：实现集合接口，返回一个具体的迭代器对象。

适用场景：

1. 访问集合需要屏蔽内部时间。
2. 为一个集合提供多种遍历方式。

优点：

1. 对使用者屏蔽了复杂的数据结构。
2. 对遍历操作封装到了单独的类中，使集合和迭代器职责更加单一。
3. 可以轻易替换遍历代码，更加符合开闭原则。

优点：

1. 迭代算法可能过于复杂，优先使用开发语言提供的方式可能会更好。

代码(C#)

/// <summary>
/// 抽象迭代器
/// </summary>
/// <typeparam name="T"></typeparam>
public interface ITerator<T>
{
    bool HasNext();
    void Next();
    T CurrentItem();
}

/// <summary>
/// 具体迭代器
/// </summary>
/// <typeparam name="T"></typeparam>
public class ListIterator<T> : ITerator<T>
{
    private int _cursor;
    private List<T> _list;

    public ListIterator(List<T> list)
    {
        _list = list;
    }

    public bool HasNext()
    {
        return _cursor != _list.Count;
    }

    public void Next()
    {
        _cursor++;
    }

    public T CurrentItem()
    {
        if (_cursor >= _list.Count)
            throw new NullReferenceException();

        return _list[_cursor];
    }
}

/// <summary>
/// 抽象集合
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IAggregate<T>
{
    ITerator<T> CreateIterator();
}

/// <summary>
/// 具体集合
/// </summary>
/// <typeparam name="T"></typeparam>
public class ConcreteList<T> : IAggregate<T>
{
    private readonly List<T> _collection;

    public ConcreteList()
    {
        _collection = new List<T>();
    }

    public void AddItem(T item)
    {
        _collection.Add(item);
    }

    public ITerator<T> CreateIterator()
    {
        return new ListIterator<T>(_collection);
    }
}

ConcreteList<int> concreteList = new ConcreteList<int>();
concreteList.AddItem(1);
concreteList.AddItem(2);
concreteList.AddItem(3);
concreteList.AddItem(4);

ITerator<int> iterator = concreteList.CreateIterator();

while (iterator.HasNext())
{
    Console.WriteLine(iterator.CurrentItem());
    iterator.Next();
}

最后

在大部分语言语言中都可以通过for、foreach来遍历集合，foreach的本质其实就是迭代器模式。在遍历的过程中，通常是不允许修改集合中的元素，增加或者删除集合中的元素，有可能会导致某个元素被重复遍历或遍历不到，这种行为称为结果不可预期行为或者未决行为。