13.行为型 - 迭代器模式 （Iterator）

1.定义

• 提供一种顺序访问（遍历）容器中各个元素的方法
• 高频使用的设计模式，但是很少需要单独实现，容器类几乎都已经封装好

2.UML类图

• 角色介绍
  IIterator : 抽象迭代器接口
  ConcreteIterator : 具体迭代器，实现遍历容器的方法
  IAggregate : 抽象容器接口，提供创建具体迭代器接口
  ConcreteAggregate : 具体容器
• 要点
  容器接口中需要定义创建具体迭代器的接口

3.UML示例代码

/**
 * Copyright (C), 2016-2020
 * FileName: IIterator
 * Author: wei.zheng
 * Date: 2019/12/17 9:36
 * Description: 迭代器抽象接口
 */
public interface IIterator<T> {
    boolean hasNext();

    T next();
}

/**
 * Copyright (C), 2016-2020
 * FileName: ConcreteIterator
 * Author: wei.zheng
 * Date: 2019/12/17 9:38
 * Description: 具体迭代器
 */
public class ConcreteIterator<T> implements IIterator<T> {
    private List<T> list;
    private int cursor = 0;

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

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

    @Override
    public T next() {
        T object = null;
        if (hasNext()) {
            object = list.get(cursor++);
        }
        return object;
    }
}

/**
 * Copyright (C), 2016-2020
 * FileName: IAggregate
 * Author: wei.zheng
 * Date: 2019/12/17 9:37
 * Description: 容器抽象接口
 */
public interface IAggregate<T> {
    void add(T object);

    void remote(T object);

    IIterator<T> iterator();
}

/**
 * Copyright (C), 2016-2020
 * FileName: ConcreteAggregate
 * Author: wei.zheng
 * Date: 2019/12/17 9:43
 * Description: 具体容器, 不同的容器可以有不同的迭代器实现，这里以List为例；还可以是Array or Map
 */
public class ConcreteAggregate<T> implements IAggregate<T> {
    private List<T> list = new ArrayList();

    @Override
    public void add(T object) {
        list.add(object);
    }

    @Override
    public void remote(T object) {
        list.remove(object);
    }

    @Override
    public IIterator<T> iterator() {
        return new ConcreteIterator<>(list);
    }
}

/**
 * Copyright (C), 2016-2020
 * FileName: Client
 * Author: wei.zheng
 * Date: 2019/12/17 9:44
 * Description: 迭代器模式用户类
 */
public class Client {
    public static void main(String[] args) {
        IAggregate<String> sports = new ConcreteAggregate<>();
        sports.add("Football");
        sports.add("Basketball");
        sports.add("Volleyball");

        IIterator<String> iterator = sports.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

// 运行结果
2019-12-17 22:11:35.652 8975-8975/? I/System.out: Football
2019-12-17 22:11:35.652 8975-8975/? I/System.out: Basketball
2019-12-17 22:11:35.652 8975-8975/? I/System.out: Volleyball

4.总结

用迭代器来遍历容器中的元素，具体迭代器由具体容器来指定。
优点：弱化了容器类与遍历算法的关系
缺点：增加了类文件（迭代器类）（相比其他设计模式，此模式的类膨胀算是比较小的）