【设计模式-迭代】

定义

迭代器模式（Iterator Pattern）是一种行为型设计模式，用于提供一种顺序访问集合对象元素的方式，而不暴露该对象的内部表示。通过迭代器，客户端可以在不需要了解集合实现的细节的情况下遍历集合中的元素。

UML图

角色

• Iterator（迭代器接口）：定义了访问和遍历集合元素的方法，如 next()、hasNext() 等。
• ConcreteIterator（具体迭代器）：实现迭代器接口，维护对集合的引用，并提供遍历集合的具体逻辑。
• Aggregate（聚合接口）：定义创建迭代器的接口，通常有一个方法返回一个迭代器实例。
• ConcreteAggregate（具体聚合类）：实现聚合接口，维护集合的内部数据结构，并提供创建具体迭代器的方法。

流程

1. 客户端请求聚合对象的迭代器。
2. 迭代器返回一个具体的迭代器实例，客户端使用该迭代器访问集合元素。
3. 迭代器提供的方法用于遍历集合，不需要客户端了解集合的具体实现。

代码

import java.util.ArrayList;
import java.util.List;

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

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

// 具体迭代器
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() {
        return hasNext() ? items.get(position++) : null;
    }
}

// 具体聚合类
class ConcreteAggregate<T> implements Aggregate<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 IteratorPatternDemo {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");

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

优点

• 解耦：客户端与集合的内部表示解耦，客户端只需关注如何使用迭代器，而无需关心集合的具体实现。
• 多种遍历方式：可以为同一集合提供多种不同的迭代器，支持不同的遍历策略。
• 简化集合接口：将遍历功能抽象为迭代器，使集合接口更简单，关注于集合本身的操作。

缺点

• 增加系统复杂性：引入迭代器模式会增加系统中的类数量，可能导致代码复杂性提高。
• 性能开销：在某些情况下，使用迭代器可能引入额外的性能开销。

适用场景

• 需要访问集合中的元素：如列表、集合、树等数据结构的遍历。
• 不同遍历方式的需求：当同一集合需要多种遍历方式时，迭代器模式非常适用。
• 对集合的封装：希望隐藏集合的内部结构，提供统一的访问接口时。