迭代器模式

迭代器模式（Iterator Pattern）是一种行为设计模式，旨在提供一种方法顺序访问一个聚合对象（如列表、集合）中的各个元素，而无需暴露其内部表示。这种模式的核心是将遍历行为封装在迭代器对象中，使得客户端代码可以统一地处理不同类型的集合或容器。

主要角色

1. 迭代器接口（Iterator）：定义了访问和遍历元素的方法，例如 hasNext() 和 next()。
2. 具体迭代器（Concrete Iterator）：实现迭代器接口，负责遍历集合中的元素。
3. 聚合接口（Aggregate）：定义创建迭代器的接口，如 createIterator()。
4. 具体聚合（Concrete Aggregate）：实现聚合接口，通常会包含集合的实现并返回一个具体的迭代器实例。

迭代器模式的优点

• 分离遍历算法与集合结构：通过引入迭代器，集合的内部结构对客户端是透明的，客户端无需了解集合的内部结构就可以遍历其中的元素。
• 支持不同集合的统一遍历：可以使用同一套遍历逻辑来处理不同类型的集合，如数组、链表、树等。
• 单一职责原则：将遍历操作从集合类中分离出来，简化了集合类的设计。

迭代器模式的缺点

• 额外的类和对象：引入了迭代器类，可能会增加程序的复杂性。
• 对资源消耗较大的遍历不友好：如果集合非常庞大或遍历操作开销较大，迭代器模式的实现可能不是最佳选择。

示例代码

//迭代器接口（Iterator）
public interface Iterator {
    boolean hasNext();
    Object next();
}
//具体迭代器（Concrete Iterator）
public class ConcreteIterator implements Iterator {
    private List<Object> list;
    private int position;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
        this.position = 0;
    }

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

    @Override
    public Object next() {
        if (hasNext()){
            return list.get(position++);
        }
        return null;
    }
}

//聚合接口（Aggregate）
public interface Aggregate {
    Iterator createIterator();
}
//具体聚合（Concrete Aggregate）
public class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<>();

    void add(Object o){
        list.add(o);
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(list);
    }
}

//客户端
public class TestIteratorPattern {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.add(" 第一个 ");
        aggregate.add(" 第二个 ");
        aggregate.add(" 第三个 ");

        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

应用场景

• 访问集合对象的内容而不暴露它的内部表示。
• 为遍历不同集合结构提供统一的接口。
• 需要支持多个遍历方式时（如正序、倒序遍历）。

迭代器模式在处理集合、容器等数据结构时，可以极大地提高代码的灵活性和可维护性。