设计模式系列：搞懂迭代器模式，实现集合遍历

迭代器（Iterator）模式的定义：提供一种顺序访问集合/容器对象中的一系列数据的方法，而又无需暴露集合的内部表示。属于行为型模式。

迭代器模式的本质是抽离集合对象迭代行为到迭代器中，提供一致访问接口。

迭代器模式的结构：迭代器模式主要包含以下4个角色。

1. 抽象容器（Aggregate）：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体容器（ConcreteAggregate）：实现抽象容器，返回一个具体迭代器的实例。
3. 抽象迭代器（Iterator）：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4. 具体迭代器（Concretelterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历。

迭代器模式的实现：

//抽象迭代器
public interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

//具体迭代器
public class ConcreteIterator implements Iterator{
    private List<Object> list;
    private int index = -1;

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

    @Override
    public Object first() {
        index = 0;
        Object obj = list.get(index);;
        return obj;
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = list.get(++index);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {
        if (index < list.size() - 1) {
            return true;
        } else {
            return false;
        }
    }
}

//抽象容器
public interface Aggregate {
    void add(Object obj);

    void remove(Object obj);

    Iterator getIterator();
}

//具体容器
public class ConcreteAggregate implements Aggregate{
    private List<Object> list = new ArrayList<>();

    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

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

//测试类
public class IteratorTest {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("秦朝");
        aggregate.add("汉朝");
        aggregate.add("隋朝");
        aggregate.add("唐朝");
        System.out.print("聚合的内容有：");
        Iterator it = aggregate.getIterator();
        while (it.hasNext()) {
            Object ob = it.next();
            System.out.print(ob.toString() + "，");
        }
        Object ob = it.first();
        System.out.println("First：" + ob.toString());
    }
}

迭代器模式的结构图：

迭代器模式在源码中的应用：最经典的应用就是Jdk中的迭代器Iterator。

迭代器模式的优点：

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

迭代器模式的缺点：对于比较简单的遍历，使用迭代器方式遍历较为繁琐。

迭代器模式的应用场景：

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