设计模式——迭代器模式

简述

迭代器模式：提供一种方法顺序地访问或遍历一个对象中的各个元素，而又不用暴露该对象的内部表示。迭代器模式又称游标模式，它是一种对象行为型模式。通过引入迭代器可以将数据的遍历功能从聚合对象中分离出来，聚合对象只负责存储数据，而遍历数据由迭代器完成，符合单一职责原则。

角色

（1）Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历元素的方法。

（2）ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成了对聚合对象元素遍历方法的具体实现。

（3）Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明了一个createIterator方法用于创建一个迭代器对象。

（4）ConcreteAggregate(具体聚合类)：它是抽象聚合类的子类，实现了在抽象聚合类中声明的createIterator（）方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

实现

（1）创建抽象迭代器类：

/**
 * 迭代器接口
 */
public interface Iterator {
     boolean hasNext();//是否存在下一条记录

    Object next();//返回当前记录并移动到下一条记录
}

（2）创建具体迭代器类：

/**
 * 具体迭代器
 */
public class ConcreteIterator implements Iterator {
    private Aggregate aggregate;
    private int index;

    public ConcreteIterator(Aggregate aggregate){
        this.aggregate=aggregate;
    }

    @Override
    public boolean hasNext() {
        if (index<aggregate.size()){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public Object next() {
        return aggregate.get(index++);
    }
}

（3）创建抽象聚合对象：

/**
 * 抽象容器类
 */
public interface Aggregate {

    int size();//容器的大小

    String get(int position);//获取指定位置的号码

    void add(String tel);//往容器中添加

    void remove(String tel);//从容器中移除

    Iterator iterator();//返回容器的迭代器
}

（4）创建具体的聚合对象类：

/**
 * 具体容器类
 */
public class ConcreteAggregate implements Aggregate {
    private ArrayList<String> list=new ArrayList<>();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public String get(int position) {
        return list.get(position);
    }

    @Override
    public void add(String tel) {
        list.add(tel);
    }

    @Override
    public void remove(String tel) {
        list.remove(tel);
    }

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

测试迭代器模式：

public class TestIterator {
    public static void main(String[] args) {
        Aggregate aggregate=new ConcreteAggregate();
        aggregate.add("北京");
        aggregate.add("上海");
        aggregate.add("广州");
        aggregate.add("深圳");
        aggregate.add("香港");

        Iterator iterator=aggregate.iterator();
        while (iterator.hasNext()){
            Log.e("====","======"+iterator.next());
        }
    }
}

优点

（1）迭代器模式支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，也可以自己定义迭代器的子类以支持新的遍历方式。

（2）迭代器模式的引入，使聚合类的职责更加单一，聚合对象负责储存和管理对象，而迭代器负责对聚合对象中元素的遍历。符合设计模式的单一职责原则。

（3）使用抽象的迭代器，再增加新的迭代器类很方便，无需修改原有代码，满足开放封闭原则。

缺点

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

（2）抽象迭代器的设计难度比较大，要充分考虑可拓展性。

小结

（1）迭代器模式提供一种方法顺序访问聚合对象内部的元素，而又不用暴露该对象内部。

（2）迭代器模式包含抽象迭代器、具体迭代器、抽象聚合类、具体聚合类4个角色。其中抽象迭代器定义了访问和遍历元素的接口，声明了用于遍历元素数据的方法；具体迭代器实现了抽象迭代器接口，完成了对聚合对象的遍历。抽象聚合类用于储存和管理元素对象；具体聚合类是抽象聚合类的子类，实现了在抽象聚合类中声明的方法。