迭代器模式详解：原理、实现与应用场景

1. 迭代器模式概述

迭代器模式是一种行为设计模式，它允许你在不暴露集合底层实现细节的情况下，顺序访问集合中的各个元素。这种模式在软件开发中极为常见，特别是在需要遍历不同类型集合的场景下。

想象一下你去图书馆找书的场景。你可以选择：

• 自己逐个书架查找（直接操作集合）
• 使用图书馆的检索系统（迭代器）
• 请图书管理员帮忙（高级迭代器）

显然后两种方式更高效，这就是迭代器模式的价值所在。它把遍历的责任从集合类中分离出来，交给专门的迭代器对象，使得集合和遍历逻辑可以独立变化。

2. 迭代器模式的核心结构

2.1 模式参与者

迭代器模式通常包含以下几个关键角色：

1. Iterator（迭代器接口）

   • 定义访问和遍历元素的接口
   • 通常包含hasNext()和next()等基本方法

2. ConcreteIterator（具体迭代器）

   • 实现迭代器接口
   • 跟踪遍历过程中的当前位置
   • 不同迭代器可以实现不同的遍历策略

3. Aggregate（集合接口）

   • 定义创建迭代器对象的接口
   • 通常是一个创建迭代器的工厂方法

4. ConcreteAggregate（具体集合）

   • 实现创建迭代器的接口
   • 返回一个适合该集合的具体迭代器实例

2.2 类图解析

用文字描述类图关系：

code复制[Client] --> [Aggregate]
[Client] --> [Iterator]
[Aggregate] <|-- [ConcreteAggregate]
[Iterator] <|-- [ConcreteIterator]
[ConcreteAggregate] --> [ConcreteIterator]

这种结构使得客户端可以：

• 通过Aggregate接口获取迭代器
• 通过Iterator接口遍历元素
• 无需关心具体集合和迭代器的实现细节

3. 迭代器模式的实现细节

3.1 基础实现示例（Java版）

java复制// 迭代器接口
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

// 集合接口
public interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 具体集合
public class ConcreteAggregate<T> implements Aggregate<T> {
    private T[] items;
    
    public ConcreteAggregate(T[] items) {
        this.items = items;
    }
    
    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }
    
    public int size() {
        return items.length;
    }
    
    public T get(int index) {
        return items[index];
    }
}

// 具体迭代器
public class ConcreteIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;
    private int index = 0;
    
    public ConcreteIterator(ConcreteAggregate<T> aggregate) {
        this.aggregate = aggregate;
    }
    
    @Override
    public boolean hasNext() {
        return index < aggregate.size();
    }
    
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return aggregate.get(index++);
    }
}

3.2 使用示例

java复制public class Client {
    public static void main(String[] args) {
        String[] data = {"A", "B", "C", "D"};
        Aggregate<String> aggregate = new ConcreteAggregate<>(data);
        Iterator<String> iterator = aggregate.createIterator();
        
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

4. 迭代器模式的高级应用

4.1 多种遍历方式支持

同一个集合可以支持多种遍历方式，只需提供不同的迭代器实现：

java复制// 逆序迭代器
public class ReverseIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;
    private int index;
    
    public ReverseIterator(ConcreteAggregate<T> aggregate) {
        this.aggregate = aggregate;
        this.index = aggregate.size() - 1;
    }
    
    @Override
    public boolean hasNext() {
        return index >= 0;
    }
    
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return aggregate.get(index--);
    }
}

// 在集合中增加创建方法
public class ConcreteAggregate<T> implements Aggregate<T> {
    // ...其他代码同上...
    
    public Iterator<T> createReverseIterator() {
        return new ReverseIterator<>(this);
    }
}

4.2 过滤迭代器

可以实现只返回满足特定条件的元素的迭代器：

java复制public class FilteringIterator<T> implements Iterator<T> {
    private Iterator<T> source;
    private Predicate<T> predicate;
    private T nextItem;
    private boolean nextReady = false;
    
    public FilteringIterator(I