行为型模式之迭代器模式(Iterator Pattern)

1.定义

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

2.迭代器模式构成

• 抽象迭代器（Iterator）角色：抽象角色定义出遍历元素所需的接口
• 具体迭代器（ConcreteIterator）角色：此角色实现了Iterator接口，并保持迭代过程中游标的位置
• 聚集（aggregate）角色：此抽象角色给出了创建迭代器的接口
• 具体聚集（ConcreteAggregate）角色：此角色实现了创建迭代器的接口，返回一个合适的具体迭代器实例
• 客户端（Client）角色：持有对聚集对象及迭代器子类的引用，调用迭代子类的接口，也有可能通过迭代器调用聚集元素的增加和删除

3.实例

设计一个逐页迭代器，每次可返回指定个数（一页）元素，并将该迭代器用于对数据进行分页处理。

3.1 UML & Sequence

 

3.2 代码

/**
 * @ClassName launcher
 * @Description: 迭代器模式
 * @Author cw
 * @Date 2020/3/4
 **/
public class Client {

    /**
     * 设计一个逐页迭代器，每次可返回指定个数（一页）元素，并将该迭代器用于对数据进行分页处理
     * @param args
     */
    public static void main(String[] args) {
        //定义分页数据
        List<String> lstData = new LinkedList<>();

        //创建聚合对象
        AbstractAggregateData abstractAggregateData = new PageAggregateData(lstData);
        for(int i=1;i<=101;i++){
            abstractAggregateData.addData("第"+i+"条");
        }

        //创建迭代器对象
        AbstractIterator pageIterator = abstractAggregateData.createIterator();

        //每一页迭代
        while(pageIterator.hasNextPage()){
            pageIterator.nextPage();
        }

        //分页按钮
        pageIterator.firstPage();//第一页
        pageIterator.lastPage();//最后一页
        pageIterator.previousPage();//上一页
        pageIterator.nextPage();//下一页

    }
}

/**
 * 抽象聚合类
 */
abstract class AbstractAggregateData{
    private List<String> lstData ;

    public AbstractAggregateData(List<String> lstData){
        this.lstData = lstData;
    }

    protected void addData(String data){
        this.lstData.add(data);
    }

    protected void removeData(String data){
        this.lstData.remove(data);
    }

    protected List<String> getData(){
        return lstData;
    }
    //声明迭代器
    protected abstract AbstractIterator createIterator();

}

/**
 * 分页数据类：具体的聚合类
 */
class PageAggregateData extends AbstractAggregateData{
    public PageAggregateData(List<String> lstData) {
        super(lstData);
    }

    @Override
    protected AbstractIterator createIterator() {
        return new PageIterator(this);
    }
}

/**
 * 抽象迭代器
 */
abstract class AbstractIterator{
    protected abstract void previousPage();
    protected abstract void nextPage();
    protected abstract void currentPage();
    protected abstract void firstPage();
    protected abstract void lastPage();
    protected abstract boolean hasNextPage();
}

/**
 * 分页迭代器：具体迭代器
 */
class PageIterator extends AbstractIterator{

    private PageAggregateData pageDataList;
    private List<String> dataList;
    private int pageCount;
    private int cursor;

    public PageIterator(PageAggregateData pageDataList){
        this.pageDataList = pageDataList;
        this.dataList = pageDataList.getData();
        pageCount = dataList.size()%10>0?dataList.size()/10+1:dataList.size()/10;
        cursor = -1;
    }

    @Override
    protected void previousPage() {
        if(cursor >0)
            cursor--;
        else
            cursor=0;
        printData();
    }

    @Override
    protected void nextPage() {
        if(cursor <pageCount-1)
            cursor++;
        printData();
    }

    @Override
    protected void currentPage() {
        printData();
    }

    @Override
    protected void firstPage() {
        cursor = 0;
        printData();
    }

    @Override
    protected void lastPage() {
        cursor=pageCount-1;
        printData();
    }

    @Override
    protected boolean hasNextPage() {
        return cursor!=(pageCount-1);
    }

    private void printData(){
        int start = cursor*10;
        int end = (cursor+1)*10;
        end = end>dataList.size()?dataList.size():end;
        System.out.println("当前第"+(cursor+1)+"页数据start=======");
        for(int i=start;i<end;i++){
            System.out.println(dataList.get(i));
        }
        System.out.println("当前第"+(cursor+1)+"页数据end=======");
    }
}