设计模式（十五）迭代器模式

1、定义

　　提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。是一种对象行为型模式。

2、优缺点

优点

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

缺点

1. 增加了类的个数，这在一定程度上增加了系统的复杂性。在日常的开发过程中，几乎很少会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的API完全够用。

3、UML类图

 主要包含以下角色：

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

 4、代码实例

/**
 * @author it-小林
 * @desc   抽象迭代器
 * @date 2021年08月04日 14:04
 */
public interface Iterator {
    public Object next();

    public boolean hasNext();
}

/**
 * @author it-小林
 * @desc   具体迭代器
 * @date 2021年08月04日 14:05
 */
public class ConcreteIterator implements Iterator{
    private List list = new ArrayList<>();
    private int cursor = 0;

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

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

    @Override
    public boolean hasNext() {
        if (cursor == list.size()){
            return false;
        }
        return true;
    }
}

/**
 * @author it-小林
 * @desc    抽象类集合
 * @date 2021年08月04日 14:09
 */
public interface Aggregate {
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator iterator();
}

/**
 * @author it-小林
 * @desc 具体聚合类
 * @date 2021年08月04日 14:11
 */
public class ConcreteAggregate implements Aggregate{
    private List list = new ArrayList();

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

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

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

/**
 * @author it-小林
 * @desc   测试类
 * @date 2021年08月04日 14:14
 */
public class Client {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("小明");
        aggregate.add("小红");
        aggregate.add("小刚");
        Iterator iterator = aggregate.iterator();
        while (iterator.hasNext()){
            String next = (String) iterator.next();
            System.out.println(next);
        }
    }
}

5、应用场景

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

6、模式的扩展

　　迭代器模式常常与组合模式结合起来使用，在对组合模式中的容器构件进行访问时，经常将迭代器潜藏在组合模式的容器构成类中。当然，也可以构造一个外部迭代器来对容器构件进行访问，其结构图如图。