一、基础简介

1、定义

提供一种方法顺序访问一个聚合对象的各个元素，而又不暴露该对象的内部表示。

备注：现今，迭代模式的实用价值已经远不如学习价值了，因为在高级语言中，如JAVA，本身就已经将该模式做在语言中了，比如：foreach in 、iterator。

2、使用场景

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就考虑使用该模式。

• 1、访问一个聚合对象的内容而无须暴露它的内部表示。
• 2、需要为聚合对象提供多种遍历方式。
• 3、为遍历不同的聚合结构提供一个统一的接口。

3、优缺点

优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

4、模式结构分析

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

二、实例实现

1、抽象迭代器（Iterator）角色

package com.mfc.design.迭代器模式;

/**
 * @author MouFangCai
 * @date 2019/10/21 15:23
 *
 * @description 迭代器抽象类
 */
public abstract class Iterator {

    public abstract Object next();
    public abstract boolean hasNext();
}

2、具体迭代器（Concretelterator）角色

package com.mfc.design.迭代器模式;

/**
 * @author MouFangCai
 * @date 2019/10/21 15:37
 *
 * @description 具体的迭代器类
 */
public class ConcreteIterator extends Iterator{

    private ConcreteAggregate aggregate;
    private int current = 0;

    // 初始化聚集对象
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public Object next() {
        Object result = null;
        if (current < aggregate.count()){
           result =  aggregate.getOne(current);
           current ++ ;
        }
        return result;
    }

    @Override
    public boolean hasNext() {
        return current < aggregate.count();
    }

}

3、抽象聚合（Aggregate）角色

package com.mfc.design.迭代器模式;

/**
 * @author MouFangCai
 * @date 2019/10/21 15:36
 *
 * @description 聚合抽象类
 */
public abstract class Aggregate {

    // 创建迭代器
    public abstract Iterator createIterator();
}

4、具体聚合（ConcreteAggregate）角色

package com.mfc.design.迭代器模式;

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

/**
 * @author MouFangCai
 * @date 2019/10/21 15:38
 *
 * @description 具体的聚集类
 */
public class ConcreteAggregate<T> extends Aggregate {

    // 存放集合对象
    private List<T> items = new ArrayList<>();

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

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

    public T getOne(int index){
        return items.get(index);
    }

    public void setItems(List<T> items) {
        this.items = items;
    }
}

5、客户端

package com.mfc.design.迭代器模式;

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

/**
 * @author MouFangCai
 * @date 2019/10/21 15:20
 *
 * @description
 */
public class Client_Iterator {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();
        for (int i = 1; i < 5; i++) {
            items.add("成员-" + i);
        }
        // 创建一个聚集对象
        ConcreteAggregate<String> concreteAggregate = new ConcreteAggregate();
        concreteAggregate.setItems(items);

        // 迭代器遍历
        ConcreteIterator iterator = new ConcreteIterator(concreteAggregate);
        while (iterator.hasNext()){
            System.out.println("遍历----" + iterator.next().toString());
        }

    }
}

6、结果展示

遍历----成员-1
遍历----成员-2
遍历----成员-3
遍历----成员-4

Process finished with exit code 0