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

1、概述

迭代器模式是一种行为设计模式， 让你能在不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素。

2、适用场景

1） 当集合背后为复杂的数据结构， 且你希望对客户端隐藏其复杂性时 （出于使用便利性或安全性的考虑）， 可以使用迭代器模式。
2）使用该模式可以减少程序中重复的遍历代码。
3）如果你希望代码能够遍历不同的甚至是无法预知的数据结构， 可以使用迭代器模式。

3、实例

有如下场景：

有一辆公交车，车上有一个售票员在卖票。
有五位乘客上车，分别是：
小明，小赵，小钱，小孙，小李。

迭代模式实现。

抽象迭代器：

/**
 * 抽象迭代器
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public interface AbstractIterator {

    String first();

    boolean hasNext();

    String next();

    String current();

}

抽象集合：

/**
 * 抽象集合
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public interface AbstractAggregate {

    AbstractIterator iterator();
}

公交集合：

import java.util.List;

/**
 * bus集合
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class BusAggregate implements AbstractAggregate {

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    private List<String> list;

    public BusAggregate(List<String> list) {
        this.list = list;
    }

    @Override
    public AbstractIterator iterator() {
        return new ConductorIterator(this);
    }
}

售票员迭代器：

/**
 * 售票员迭代
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class ConductorIterator implements AbstractIterator {

    private BusAggregate aggregate;

    private int current = 0;

    @Override
    public String first() {
        return aggregate.getList().get(0);
    }

    @Override
    public boolean hasNext() {
        if (aggregate.getList().size() > current) {
            return true;
        }
        return false;
    }

    @Override
    public String next() {
        return aggregate.getList().get(current++);
    }

    public ConductorIterator(BusAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public String current() {
        return aggregate.getList().get(current);
    }
}

测试类：

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

/**
 * 测试类
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class TestDemo {

    public static void main(String[] args) {
        //初始化几个乘客
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小赵");
        list.add("小钱");
        list.add("小孙");
        list.add("小李");
        //初始化一个公交处
        BusAggregate busAggregate = new BusAggregate(list);
        //初始化一个售票员
        ConductorIterator conductorIterator = new ConductorIterator(busAggregate);
        String name = conductorIterator.first();
        System.out.println("第一位买票的乘客是：" + name);
        while (conductorIterator.hasNext()) {
            if (name.equals(conductorIterator.current())){
                conductorIterator.next();
                continue;
            }
            System.out.println("下一位买票的乘客是：" + conductorIterator.next());
        }

    }
}

4、分析

迭代模式结构

如上面的图和代码所示，迭代模式要求我们有顶层抽象迭代器，和顶层的抽象集合。具体迭代器实现顶层抽象迭代器，具体集合实现顶层的抽象集合接口。

具体聚合类 具体的迭代器

5、总结

优点：
1）单一职责原则。
2）开闭原则。 你可实现新型的集合和迭代器并将其传递给现有代码， 无需修改现有代码。
3）你可以并行遍历同一集合， 因为每个迭代器对象都包含其自身的遍历状态。
4）你可以暂停遍历并在需要时继续。
缺点：
1）如果你的程序只与简单的集合进行交互， 应用该模式可能会矫枉过正。
2）对于某些特殊集合， 使用迭代器可能比直接遍历的效率低。