java实现迭代器模式

迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供一种方法来顺序访问一个聚合对象（如列表、集合、数组等）中的元素，而不暴露聚合对象的内部表示。迭代器模式通常包括以下角色：迭代器（Iterator）、具体迭代器（Concrete Iterator）、聚合（Aggregate）、具体聚合（Concrete Aggregate）。

以下是一个简单的Java示例，演示如何实现迭代器模式：

首先，定义迭代器接口 Iterator，它包括用于访问元素的方法：

public interface Iterator {
    boolean hasNext();
    Object next();
}

然后，定义聚合接口 Aggregate，它包括创建迭代器的方法：

public interface Aggregate {
    Iterator createIterator();
}

接下来，创建具体聚合类 ConcreteAggregate，实现 Aggregate 接口，并包括一个内部数据结构（例如数组或列表）：

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

public class ConcreteAggregate implements Aggregate {
    private List<Object> items = new ArrayList<>();

    public void addItem(Object item) {
        items.add(item);
    }

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

    public Object getItem(int index) {
        return items.get(index);
    }

    public int size() {
        return items.size();
    }
}

然后，创建具体迭代器类 ConcreteIterator，实现 Iterator 接口，并维护一个对聚合对象的引用以访问元素：

public class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int currentIndex = 0;

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }

    @Override
    public Object next() {
        if (hasNext()) {
            return aggregate.getItem(currentIndex++);
        }
        throw new NoSuchElementException();
    }
}

最后，我们可以使用迭代器模式来顺序访问聚合对象中的元素：

public class IteratorPatternDemo {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");

        Iterator iterator = aggregate.createIterator();

        while (iterator.hasNext()) {
            Object item = iterator.next();
            System.out.println("Item: " + item);
        }
    }
}

在这个示例中，我们创建了一个具体聚合 ConcreteAggregate，并向其添加了三个元素。然后，我们创建了一个迭代器 ConcreteIterator 来顺序访问聚合中的元素。通过使用迭代器模式，我们可以在不暴露聚合内部结构的情况下遍历聚合对象。

迭代器模式通常用于遍历和访问集合、列表、数组等数据结构，它将遍历算法与数据结构分离，使得算法可以独立变化。这提高了代码的灵活性和可维护性。