大话设计模式——迭代器模式

迭代器模式

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

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。

你需要对聚集有多种方式遍历时，可以考虑使用迭代器模式。

为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。foreach就是迭代器模式，不需要知道集合对象是什么。

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

Iterator迭代器抽象类

public abstract class Iterator {
    // 用于定义得到开始对象、得到下一个对象、判断是否到结尾、当前对象等抽象方法，统一接口。
    public abstract Object first();
    public abstract Object next();
    public abstract boolean isDone();
    public abstract Object currentItem();
}

Aggregate聚集抽象类

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

ConcreteIterator具体迭代器类

public class ConcreteIterator extends Iterator {

    /**
     * 定义一个具体聚集对象
     */
    private ConcreteAggregate aggregate;
    private int current = 0;

    /**
     * 初始化时将具体的聚集对象传入
     */
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

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

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

    /**
     * 判断当前是否遍历到结尾，到结尾返回true
     */
    @Override
    public boolean isDone() {
        return current >= aggregate.count() ? true : false;
    }

    /**
     * 返回当前的聚集对象
     */
    @Override
    public Object currentItem() {
        return aggregate.getObject(current);
    }

}

ConcreteAggregate具体聚集类

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

public class ConcreteAggregate extends Aggregate {

    /**
     * 声明一个List泛型变量，用于存放聚合对象，用ArrayList同样可以实现
     */
    private List<Object> items = new ArrayList<Object>();

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    /**
     * 返回聚集总个数
     */
    public int count() {
        return items.size();
    }

    /**
     * 声明一个索引器
     */
    public void setObject(int index,Object value) {
        items.add(index, value);
    }

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

}

客户端

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.setObject(0, "张三丰");
        aggregate.setObject(1, "张无忌");
        aggregate.setObject(2, "殷天正");
        aggregate.setObject(3, "小昭");
        aggregate.setObject(4, "赵敏");
        aggregate.setObject(5, "朱元璋");
        
        ConcreteIterator iterator = new ConcreteIterator(aggregate);
        // 从第一个开始遍历
        Object item = iterator.first();
        while(!iterator.isDone()) {
            System.out.println(iterator.currentItem() + "  修炼武功");
            iterator.next();
        }
    }
}

从后往前遍历的迭代器

当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。
例如：从后往前遍历的迭代器。

public class ConcreteIteratorDesc extends Iterator {

    /**
     * 定义一个具体聚集对象
     */
    private ConcreteAggregate aggregate;
    private int current = 0;

    /**
     * 初始化时将具体的聚集对象传入
     */
    public ConcreteIteratorDesc(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
        current = aggregate.count() - 1;
    }

    /**
     * 得到聚集的第一个对象
     */
    @Override
    public Object first() {
        return aggregate.getObject(aggregate.count()-1);
    }

    /**
     * 得到聚集的下一个对象
     */
    @Override
    public Object next() {
        Object ret = null;
        current--;
        if (current >=0) {
            ret = aggregate.getObject(current);
        }
        return ret;
    }

    /**
     * 判断当前是否遍历到结尾，到结尾返回true
     */
    @Override
    public boolean isDone() {
        return current <0 ? true : false;
    }

    /**
     * 返回当前的聚集对象
     */
    @Override
    public Object currentItem() {
        return aggregate.getObject(current);
    }

}

注：本文内容源自程杰的《大话设计模式》