迭代器模式

About 4 min

迭代器模式，为集合中的有序访问提供了一致的方法，它让对象可以遍历另一个对象的数据集。这种模式可以帮助我们遍历数组、集合和哈希表等。

20240124214353

迭代器模式主要包含以下几个角色:

Iterator(迭代器)接口:
定义了访问和遍历元素的接口。
ConcreteIterator(具体迭代器)类:
实现了Iterator接口，完成对聚合对象的遍历。
Aggregate(聚合)接口:
定义创建相应迭代器对象的接口。
ConcreteAggregate(具体聚合)类:
实现了Aggregate接口，返回一个具体迭代器的实例。

Iterator和Aggregate是迭代器模式的核心。Iterator定义了迭代器的基本接口，Aggregate负责创建迭代器对象。

迭代器模式将迭代器的功能从聚合对象中分离出来，这样我们就可以通过迭代器来遍历不同的聚合结构，而不需要了解它们的内部实现。这使得代码更加灵活和可复用。

代码实现

迭代器接口

这里定义迭代器的抽象行为，next方法用于查找下一个元素，hasNext用于判断是否含有下一元素。这里可以参考jdk中的接口定义。

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

迭代器实现

迭代器的具体实现中实现Iterator中的抽象行为。Aggregate是聚合类，index是当前迭代器指向的元素索引。

public class ConcreteIterator<T> implements Iterator<T> {

    private final Aggregate<T> aggregate;
    private int index = 0;

    public ConcreteIterator(Aggregate<T> aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public boolean hasNext() {
        return aggregate.size() > index;
    }

    @Override
    public T next() {
        return aggregate.get(index++);
    }

}

聚合接口

Aggregate类是抽象聚合类，它定义创建迭代器对象的抽象方法。

public abstract class Aggregate<T> {
    public abstract Iterator<T> createIterator();
    public abstract void add(T info);
    public abstract int size();
    public abstract T get(int index);
}

聚合实现

ConcreteAggregate是聚合类，它负责创建迭代器对象。

public class ConcreteAggregate<T> extends Aggregate<T> {

    private final List<T> infos = new ArrayList<>();

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }

    @Override
    public void add(T info) {
        this.infos.add(info);
    }

    @Override
    public int size() {
        return this.infos.size();
    }

    @Override
    public T get(int index) {
        return this.infos.get(index);
    }
}

测试

上面的类中我们使用了泛型，这样我们就可以扩展这个模式的使用范围，如下：

public class Client {
    public static void main(String[] args) {
        Aggregate<Info> aggregate = new ConcreteAggregate<>();
        aggregate.add(new Info("info1"));
        aggregate.add(new Info("info2"));
        aggregate.add(new Info("info3"));

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

        Aggregate<String> aggregate2 = new ConcreteAggregate<>();
        aggregate2.add("string1");
        aggregate2.add("string2");
        aggregate2.add("string3");

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