迭代器模式

概念

迭代器模式是一种行为设计模式，提供一种顺序访问聚合对象中各元素的方法，无需暴露对象的内部表示。其核心作用是将聚合对象的遍历责任交给独立的迭代器对象，从而支持在不修改聚合类本身的情况下定义多种遍历方式。

作用

1.遵循单一责任原则：聚合类仅需关注数据的存储与管理，遍历逻辑由迭代器独立实现，降低类职责耦合。

2.统一遍历接口：不同聚合对象可通过实现相同的迭代器接口，提供统一的遍历方式，提升客户端代码的复用性。

3.隐藏内部细节：客户端无需了解聚合对象的内部结构（如数据存储方式），仅通过迭代器接口即可访问元素。

场景

1.需要为聚合对象提供多种遍历方式（如正序、倒序、过滤遍历）时。

2.遍历聚合对象时需隐藏其内部实现（如数据结构、存储方式）时。

3.希望以统一方式遍历不同类型的聚合结构（如列表、树、图）时。

举例

以下使用迭代器模式输出中国四大一线城市列表：

// 聚合接口
import java.util.Iterator;

interface CityAggregate {
    Iterator<City> iterator();
    void addCity(City city);
}

// 具体聚合类
class ChineseCities implements CityAggregate {
    private List<City> cities = new ArrayList<>();

    @Override
    public Iterator<City> iterator() {
        return new ChineseCitiesIterator(cities);
    }

    @Override
    public void addCity(City city) {
        cities.add(city);
    }
}

// 迭代器接口
interface CityIterator extends Iterator<City> {}

// 具体迭代器类
class ChineseCitiesIterator implements CityIterator {
    private List<City> cities;
    private int position = 0;

    public ChineseCitiesIterator(List<City> cities) {
        this.cities = cities;
    }

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

    @Override
    public City next() {
        if (!hasNext()) {
            throw new IllegalStateException("No more elements");
        }
        return cities.get(position++);
    }
}

// 城市类
class City {
    private String name;

    public City(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 测试类
public class IteratorPatternDemo {
    public static void main(String[] args) {
        ChineseCities chineseCities = new ChineseCities();
        chineseCities.addCity(new City("北京"));
        chineseCities.addCity(new City("上海"));
        chineseCities.addCity(new City("广州"));
        chineseCities.addCity(new City("深圳"));

        Iterator<City> iterator = chineseCities.iterator();
        System.out.println("中国四大一线城市：");
        while (iterator.hasNext()) {
            City city = iterator.next();
            System.out.println(city.getName());
        }
    }
}

控制台输出：

中国四大一线城市：
北京
上海
广州
深圳

反例

不使用迭代器模式时，可通过直接操作聚合对象的索引实现遍历：

public class WithoutIteratorPattern {
    public static void main(String[] args) {
        List<City> cities = new ArrayList<>();
        cities.add(new City("北京"));
        cities.add(new City("上海"));
        cities.add(new City("广州"));
        cities.add(new City("深圳"));

        System.out.println("中国四大一线城市：");
        for (int i = 0; i < cities.size(); i++) {
            City city = cities.get(i);
            System.out.println(city.getName());
        }
    }
}

控制台输出与迭代器模式一致，但此方式的缺点在于：

1.暴露聚合对象内部结构（如列表的索引），客户端需了解数据存储细节。

2.若需支持多种遍历方式（如倒序、过滤），需修改遍历逻辑，降低代码可维护性和扩展性。

原理

迭代器模式的核心原理是将聚合对象的遍历逻辑从聚合类中分离，由独立的迭代器对象负责。聚合类仅提供数据存储和迭代器创建的接口，迭代器则封装了遍历的具体实现（如当前位置、遍历顺序）。这种分离使得聚合对象与遍历方式解耦，支持在不修改聚合类的情况下新增遍历策略。

缺点

1.增加系统复杂度：需引入额外的迭代器类，类数量增多，理解成本提升。

2.潜在性能开销：迭代器需维护遍历状态（如当前索引），在处理超大规模数据时可能带来额外内存或计算开销。

总结

迭代器模式通过将遍历逻辑与聚合对象解耦，实现了遍历方式的灵活扩展和内部细节的隐藏，适用于需支持多种遍历方式或保护聚合对象结构的场景。其核心价值在于提升代码的可维护性和复用性，但需权衡引入的复杂度与性能影响。