迭代器模式

定义

迭代器（Iterator）模式提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

迭代器模式是一种对象行为型模式。

要点

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。

优点：

1. 访问一个聚合对象的内容而无须暴露它的内部表示。
2. 遍历任务交由迭代器完成，这简化了聚合类。
3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：

1. 增加了类的个数，这在一定程度上增加了系统的复杂性。

主要包含以下角色：
抽象聚合（Aggregate）：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）：实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
具体迭代器（Concretelterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

场景

设计一个基于List的自定义聚合类，给定 add() 、remove()方法，必须对外隐藏聚合类的内部数据结构，所以也需要设计对应的迭代器。

实现

Aggregate

/**
 * 抽象聚合类
 */
public interface Aggregate<T> {

    void add(T t);

    void remove(T t);

    Iterator getIterator();

}

ConcreteAggregate

/**
 * 具体聚合类
 */
public class ConcreteAggregate<T> implements Aggregate<T> {

    private List<T> list = new ArrayList<>();

    @Override
    public void add(T t) {
        list.add(t);
    }

    @Override
    public void remove(T t) {
        list.remove(t);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator<T>(list);
    }
    
}

Iterator

/**
 * 抽象迭代器
 */
public interface Iterator<T> {

    T next();

    boolean hasNext();

}

ConcreteIterator

/**
 * 具体迭代器
 */
public class ConcreteIterator<T> implements Iterator<T> {

    private List<T> list;
    private int index = 0;

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

    @Override
    public T next() {
        return hasNext() ? list.get(index++) : null;
    }

    @Override
    public boolean hasNext() {
        return list.size() != 0 && index < list.size();
    }
    
}

Client

public class Client {

    public static void main(String[] args) {
        Aggregate<String> degree = new ConcreteAggregate<>();
        degree.add("小学");
        degree.add("初中");
        degree.add("高中");
        degree.add("本科");
        degree.add("硕士");
        degree.add("博士");

        // 遍历
        Iterator iterator = degree.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

----------------输出----------------
小学
初中
高中
本科
硕士
博士

源码

Click here

总结

适用场景：

1. 当需要为聚合对象提供多种遍历方式时。
2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

迭代器模式分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。