概念

提供一种方法，顺序访问一个集合对象内部的元素，而又不暴露集合的内部结构。

应用场景

需要通过迭代器封装遍历逻辑时

基本结构

1）迭代器‏接口（Iterat؜or）：定义访问和؜遍历元素的方法

2）具体迭代器‏（ConcreteItera؜tor）：实现迭代器接口，负؜责具体遍历逻辑

3）聚合接口‏（Aggregate）؜：定义创建迭代器对象的؜方法

4）具体聚‏合（Concret؜eAggregat؜e）：实现聚合接口⁡，创建对应的迭‍代器实例

代码实现

迭代器接口

定义迭代器接口

public interface Iterator<T> {
    boolean hasNext();

    T next();
}

具体迭代器

内部包含目标聚合的引用（迭代器和目标聚合在内存上是同一块空间）

public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> items;
    private int position = 0;

    public ConcreteIterator(List<T> items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        return position < items.size();
    }

    @Override
    public T next() {
        if (hasNext()) {
            T item = items.get(position);
            position++;
            return item;
        }
        throw new IndexOutOfBoundsException("No more elements");
    }
}

聚合接口

提供返回迭代器的方法

public interface IterableCollection<T> {
    Iterator<T> createIterator();
}

具体聚合

实现返回迭代器的方法

public class ConcreteCollection<T> implements IterableCollection<T> {
    private List<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(items);
    }
}

客户端调用

public class IteratorPatternExample {
    public static void main(String[] args) {
        ConcreteCollection<String> collection = new ConcreteCollection<>();
        collection.addItem("Item 1");
        collection.addItem("Item 2");
        collection.addItem("Item 3");

        Iterator<String> iterator = collection.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

优缺点

优点

1）简化遍历操作：提供了统一的接口来访问集合中的元素，客户端不需要关心集合的具体实现

2）避免暴露集合的内部结构

缺点

1）只能一次遍历：标准的迭代器模式通常只支持单一方向的遍历，并且在遍历过程中无法回溯

概念