Java设计模式之迭代器模式

一、概念与作用

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

二、使用场景

当需要为聚合对象提供多种遍历方式，或者在遍历聚合对象时需要隐藏其内部表示，或者希望在多个不同的场景中以统一的方式遍历不同的聚合结构时，迭代器模式都非常适用。

三、示例

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

1.聚合接口

import java.util.Iterator;

// 聚合接口
interface CityAggregate {
    Iterator<City> iterator();
    void addCity(City city);
}

2.具体聚合类

// 具体聚合类
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);
    }
}

3.迭代器接口

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

4.具体迭代器类

// 具体迭代器类
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++);
    }
}

5.城市类

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

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

    public String getName() {
        return name;
    }
}

6.测试类

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());
        }
    }
}

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

四、优缺点

优点

1.单一责任原则：将遍历聚合对象的职责交给迭代器，使得聚合类只需要关注数据的存储，而不需要关心数据的遍历。

2.统一接口：不同的聚合对象可以提供不同的迭代器实现，但都遵循相同的迭代器接口，从而可以在不修改客户端代码的情况下，为不同的聚合对象提供统一的遍历方式。

3.隐藏内部细节：客户端代码无需了解聚合对象的内部结构，只需通过迭代器接口即可访问聚合对象中的元素。

缺点

1.增加复杂度：引入了额外的类（迭代器类），使得系统变得更加复杂。

2.性能开销：在某些情况下，迭代器模式可能会带来一定的性能开销，尤其是在处理大量数据时。

五、不使用迭代器模式的实现

如果不使用迭代器模式，可以通过直接操作聚合对象的索引来实现遍历。以下是一个示例：

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());
        }
    }
}

这种方式直接通过索引访问列表中的元素，无需使用迭代器。然而，这种方式的缺点在于它暴露了聚合对象的内部结构（如列表的索引），并且在需要支持多种遍历方式时，代码的可维护性和扩展性较差。