模式16. 迭代器模式-java

1.定义

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

为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口、

2.应用场景

• 需要访问一个聚集对象，而不管这些对象是什么都需要遍历的时候；
• 需要对聚集对象有多种方式遍历时

好处

分离了集合对象的遍历行为，抽象出一个迭代器类来负责，既可以做到不暴露集合的内部结构，又可以让外部代码透明的访问集合内部的数据。

3.代码示意

Iterator迭代器抽象类

package designmode.iterator;
/*
* 用于定义得到开始对象，得到下一个对象、判断是否到结尾，当前对象等抽象方法，统一接口
* */
public abstract  class Iterator {
    public abstract Object First();
    public  abstract  Object Next();
    public  abstract  boolean IsDone();
    public  abstract Object CurrentItem();
}

Aggregate聚集抽象类

package designmode.iterator;
//创建迭代器
public abstract  class Aggregate {
    public abstract Iterator CreateIterator();
}

ConcreteAggregate具体聚集类

package designmode.iterator;

import leetcode.ListNode;

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

public class ConcreteAggregate extends Aggregate{
    //声明一个泛型变量，存放聚合对象
    private List<Object> items=new ArrayList<Object>();

    public  int Count(){
        return items.size();  //返回聚集总个数
    }
    //声明索引器
    public Object getIndex(int index){
        return  items.get(index);
    }
    public  void  setItem(int index, Object obj){
        items.add(index,obj);
    }


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

ConcreteIterator 具体迭代器

package designmode.iterator;

public class ConcreteIterator extends  Iterator{
    //定义聚集对象
    private ConcreteAggregate concreteAggregate;
    private int current=0;
    //初始化的时候将具体的聚集对象传入
    public ConcreteIterator(ConcreteAggregate concreteAggregate) {
        this.concreteAggregate=concreteAggregate;
    }
    @Override    //得到聚集的第一个对象
    public Object First() {
        return concreteAggregate.getIndex(0);
    }

    @Override  //得到聚集的下一个对象
    public Object Next() {
        Object ret=null;
        current++;
        if(current<concreteAggregate.Count()){
            ret=concreteAggregate.getIndex(current);
        }
        return ret;
    }

    @Override  //判断是否遍历到结尾
    public boolean IsDone() {
        return current >= concreteAggregate.Count()?  true: false;
    }
    @Override   //返回当前聚集对象
    public Object CurrentItem() {
         return  concreteAggregate.getIndex(current);
    }
}

客户端

package designmode.iterator;

public class Client {
    public static void main(String[] args) {
        //定义一个聚集对象，比如公交车
        ConcreteAggregate a= new ConcreteAggregate();
        //初始化对象数组
        a.setItem(0,"大鸟");
        a.setItem(1,"小菜");
        a.setItem(2,"行李");
        a.setItem(3,"外国人");
        a.setItem(4,"公交公司指员");
        a.setItem(5,"小偷");

        //声明迭代器对象， 类比售票员
        Iterator i=new ConcreteIterator(a);
        Object item=i.First();  //从第一个开始遍历
        while(!i.IsDone()){
            System.out.println(i.CurrentItem()+ "  请买票");
            i.Next();
        }
    }
}

测试结果

大鸟  请买票
小菜  请买票
行李  请买票
外国人  请买票
公交公司指员  请买票
小偷  请买票

Process finished with exit code 0

这里使用ConcreteIterator 使用正向遍历实现Iterator，还可以再添加一个实现类逆向遍历实现