设计模式之迭代器模式

迭代器模式是一种行为设计模式，它提供了一种顺序访问聚合对象中的元素的方法，而不需要暴露该对象的底层表示。迭代器模式将遍历元素的责任交给迭代器对象，而不是聚合对象本身，从而使得聚合对象的接口更加简洁，同时也支持多种遍历方式。

迭代器模式的结构

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

1. Iterator（迭代器接口）：定义访问和遍历元素的接口。

2. ConcreteIterator（具体迭代器）：实现迭代器接口，负责管理当前遍历的位置。

3. Aggregate（聚合接口）：定义创建迭代器对象的接口。

4. ConcreteAggregate（具体聚合）：实现聚合接口，返回一个具体迭代器的实例。

看一个实例代码

定义一个迭代器接口

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

定义一个聚合接口

public interface Aggregate<T> {
    Iterator<T> createIterator();
}

实现具体聚合类

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

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

实现具体迭代对象

import java.util.List;

public 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() {
        if (hasNext()) {
            return items.get(position++);
        }
        return null;
    }
}

编写主类方法模式迭代的过程

public class Client {
    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());
        }
    }
}

输出：

通过创建聚合对象将元素添加进去并通过create创建迭代器对象迭代当前对象。

1. 遍历复杂数据结构：如树、图等，可以提供不同的遍历方式（深度优先、广度优先等）。并且客户端不需要知道集合的内部结构，只需通过迭代器访问元素。本质是为不同的聚合对象提供统一的遍历方式