迭代器模式

1 定义

**迭代器模式(Iterator Pattern)：**提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

2 迭代器模式结构图

Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

3代码实现

interface Iterator{
	public void first();//将游标指向第一个元素
	public void next(0;//将游标指向下一个元素
	public boolean hasNext();//判断时是否存在下一个元素
	public Object current();//获取游标指向的当前元素
}

class ConcreteIterator implement Iterator {
	private ConcreteAggregate objects; //维持一个对具体聚合对象的引用
	private int cursor; //定义一个游标,用于记录当前访问位置
	public ConcreteIterator(ConcreteAggregate objects){
		this.objects = objects;
	}

	public void first(){......}
	
	public void next(){......}

	public boolean hasNext(){.......}
	
	public Object crrentItem{.......}
}

interface Aggregate{
	.....
	public Iterator createIterator{
		return new ConcreteIterator(this);
	}
}

4 具体实例

将如下代码改为迭代器模式


代码结构图如下:

具体代码如下:

public abstract class AbstractObjectList {

    protected List<Object> objects = new ArrayList<Object>();

    public AbstractObjectList(List objects){
        this.objects = objects;
    }

    public void addObject(Object obj){
        this.objects.add(obj);
    }

    public void removeObject(Object obj){
        this.objects.remove(obj);
    }

    public List getObjects(){
        return this.objects;
    }

    //声明创建迭代器对象的抽象工厂方法
    public abstract AbstractIterator createIterator();

}

public class ProductList extends AbstractObjectList{

    public ProductList(List products) {
        super(products);
    }

    //实现创建迭代器对象的具体工厂方法
    @Override
    public AbstractIterator createIterator(){
        return new ProductIterator(this);
    }
}

//抽象迭代器
public interface AbstractIterator {

    public void next();//移至下一个元素
    public boolean isLast();//判断是否为最后一个元素
    public void previous();//移至上一个元素
    public boolean isFirst();//判断是否为第一个元素
    public Object getNextItem();//获取下一个元素
    public Object getPreviousItem();//获取上一个元素

}

public class ProductIterator implements AbstractIterator {

    private ProductList productList;
    private List products;
    private int cursor1;//定义一个游标,用于记录正向遍历的位置
    private int cursor2;//定义一个游标,用于记录逆向遍历的位置

    public ProductIterator(ProductList list){
        this.productList = list;
        this.products = list.getObjects(); //获取集合对象
        cursor1 = 0; //设置正向遍历游标的初始值
        cursor2 = products.size() - 1;//设置逆向遍历游标的初始值
    }


    @Override
    public void next() {
        if(cursor1 < products.size()){
            cursor1++;
        }
    }

    @Override
    public boolean isLast() {
        return (cursor1==products.size());
    }

    @Override
    public void previous() {
        if(cursor2 > -1){
            cursor2 --;
        }
    }

    @Override
    public boolean isFirst() {
        return (cursor2 == -1);
    }

    @Override
    public Object getNextItem() {
        return products.get(cursor1);
    }

    @Override
    public Object getPreviousItem() {
        return products.get(cursor2);
    }
}

public class Client {

    public static void main(String[] args) {
        List products = new ArrayList();
        products.add("倚天剑");
        products.add("屠龙刀");
        products.add("断肠草");
        products.add("葵花宝典");
        products.add("四十二章经");

        AbstractObjectList list = new ProductList(products);//创建聚合对象
        AbstractIterator iterator = list.createIterator();//创建迭代器对象

        System.out.println("正向遍历:");
        while (!iterator.isLast()){
            System.out.println(iterator.getNextItem() + ",");
            iterator.next();
        }

        System.out.println();
        System.out.println("-----------------------------");
        System.out.println("逆向遍历:");
        while(!iterator.isFirst()){
            System.out.println(iterator.getPreviousItem()+",");
            iterator.previous();
        }
    }
}

5优缺点及适用场景

主要优点:
(1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
(2) 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
(3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。
主要缺点:
(1) 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
(2) 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。
适用场景:
(1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
(2) 需要为一个聚合对象提供多种遍历方式。
(3) 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。