迭代器模式

迭代器模式

定义

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

解决

不同的方式来遍历整个整合对象。

优点

• 它支持以不同的方式遍历一个聚合对象。
• 迭代器简化了聚合类。
• 在同一个聚合上可以有多个遍历。
• 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点

• 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

结构

迭代器模式包含如下角色：

• Iterator: 迭代器抽象类
• Aggregate: 聚集抽象类
• ConcreteIterator: 具体迭代器类
• ConcreteAggregate：具体聚集类
  

实现

package iteratormethod;
//定义接口也行
public abstract class Iterator {
    /**
     * 用于定义得到开始对象，得到下一个对象、判断是否到结尾、当前对象等抽象想方法，统一接口
     */
    public abstract Object first();

    public abstract Object next();

    public abstract boolean isDone();

    public abstract Object currentItem();
}

package iteratormethod;
public abstract class Aggregate {
    //创建迭代器
    public abstract Iterator createIterator();
}

package iteratormethod;
public class ConcreteIterator extends Iterator{
    //定义了一个具体聚集对象
    private ConcreteAggregate aggregate;
    private int current =0;

    //初始化时，将具体聚集对象传入 ：  ”创建了个该聚集对象的迭代器“
    public ConcreteIterator(ConcreteAggregate a) {
        this.aggregate=a;
    }

    //聚集的第一个对象
    @Override
    public Object first() {
        return aggregate.getItems(0);
    }

    //聚集的下一个对象
    @Override
    public Object next() {
        Object ret=null;
        current++;
        if(current <aggregate.count())
        {
            ret = aggregate.getItems(current);
        }
        return  ret;
    }

    //是否结尾，是否结束
    @Override
    public boolean isDone() {
        return current >=aggregate.count()?true:false;
    }

    @Override
    public Object currentItem() {
        return aggregate.getItems(current);
    }
}

package iteratormethod;
import java.util.ArrayList;
import java.util.List;
public class ConcreteAggregate extends Aggregate {

    //声明List泛型，用于存放聚合对象
    private List<Object> items=new ArrayList<Object>();

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

    public int count() {
        return items.size();
    }

    public Object getItems(int index) {
        return items.get(index);
    }

    public void setItems(Object item) {
        items.add(item);
    }
}

package iteratormethod;
public class IteratorClient {
    public static void main(String[] args) {
        ConcreteAggregate a=new ConcreteAggregate();
        a.setItems("零");
        a.setItems("111111");
        a.setItems(2);
        a.setItems(3.3333);
        class Four { }
        a.setItems(new Four());

        Iterator i = new ConcreteIterator(a);
        Object item=i.first();
        while(!i.isDone())
        {
            System.out.println(i.currentItem()+"  请买票！");
            i.next();
        }
    }
}

总结

• 总的来说，迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样及可以做到不爆露集合的内部结构，又可以让外部代码透明的访问集合内部的数据。由于它太普遍了，所以各种高级语言都对它进行了封装，已经成为高级语言“本身具有的语法”，反而给人感觉此模式不常用了。