设计模式(014)行为型之迭代器模式

        迭代器模式，用于提供一种方法来顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。它将遍历和聚合分离开来，使得可以独立地改变遍历方法而不影响聚合对象。这种模式通常包括一个迭代器接口定义和一个聚合对象接口定义，以及相应的迭代器和聚合对象的实现类。

1、场景设计

实现场景：设计一个迭代器和聚合对象，迭代器依次遍历聚合对象中的数据。

2、C++实现

`ConcreteAggregate`类表示了一个具体的聚合对象，它使用了`std::vector`作为内部存储容器。`ConcreteIterator`类表示了具体的迭代器，它使用了索引来遍历聚合对象中的元素。在`main`函数中，我们创建了一个`ConcreteAggregate`对象并添加了一些元素，然后使用迭代器遍历这些元素并输出它们的值。 

#include <iostream>
#include <vector>

// 迭代器接口
class Iterator {
    public:
        virtual bool hasNext() const = 0;
        virtual int next() = 0;
};

// 聚合对象接口
class Aggregate {
    public:
        virtual Iterator* createIterator() const = 0;
        virtual void add(int element) = 0;
        virtual int size() const = 0;
        virtual int get(int index) const = 0;
};

// 具体的迭代器实现
class ConcreteIterator : public Iterator {
    private:
        const Aggregate& aggregate;
        int index;

    public:
        ConcreteIterator(const Aggregate& agg) : aggregate(agg), index(0) {}

        bool hasNext() const override {
            return index < aggregate.size();
        }

        int next() override {
            return aggregate.get(index++);
        }
};

// 具体的聚合对象实现
class ConcreteAggregate : public Aggregate {
    private:
        std::vector<int> elements;

    public:
        Iterator* createIterator() const override {
            return new ConcreteIterator(*this);
        }

        void add(int element) override {
            elements.push_back(element);
        }

        int size() const override {
            return elements.size();
        }

        int get(int index) const override {
            return elements[index];
        }
};

int main() {
    ConcreteAggregate aggregate;
    aggregate.add(1);
    aggregate.add(2);
    aggregate.add(3);

    Iterator* iterator = aggregate.createIterator();
    while (iterator->hasNext()) {
        std::cout << iterator->next() << " ";
    }
    std::cout << std::endl;

    delete iterator;

    return 0;
}

3、JAVA实现

`ConcreteAggregate`表示了一个具体的聚合对象，它使用了 Java 的 `ArrayList` 作为内部存储容器。`ConcreteIterator`表示了具体的迭代器，它使用了索引来遍历聚合对象中的元素。在 `main` 方法中，我们创建了一个 `ConcreteAggregate` 对象并添加了一些元素，然后使用迭代器遍历这些元素并输出它们的值。 

package behavioralpattern.iterator;
import java.util.ArrayList;
import java.util.List;

public class IteratorDemo {
    // 迭代器接口
    interface Iterator {
        boolean hasNext();
        int next();
    }

    // 聚合对象接口
    interface Aggregate {
        Iterator createIterator();
    }

    // 具体迭代器类
    static class ConcreteIterator implements Iterator {
        private List<Integer> elements;
        private int position;

        ConcreteIterator(List<Integer> elements) {
            this.elements = elements;
            this.position = 0;
        }

        public boolean hasNext() {
            return position < elements.size();
        }

        public int next() {
            return elements.get(position++);
        }
    }

    // 具体聚合对象类
    static class ConcreteAggregate implements Aggregate {
        private List<Integer> elements;

        ConcreteAggregate() {
            elements = new ArrayList<>();
        }

        public void add(int element) {
            elements.add(element);
        }

        public Iterator createIterator() {
            return new ConcreteIterator(elements);
        }
    }

    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.add(1);
        aggregate.add(2);
        aggregate.add(3);

        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}