迭代器模式

模式定义

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

模式结构

模式结构

Iterator:迭代器接口。定义访问和遍历元素的接口。

ConcreteIterator:具体的迭代器实现对象。实现对聚合对象的遍历,并跟踪遍历时的当前位置。

Aggregate:聚合对象。定义创建相应迭代器对象的接口。

ConcreteAggregate:具体聚合对象。实现创建相应的迭代器对象。

代码实现

public abstract class Aggregate {

    public abstract Iterator CreateIterator();
}

class ConcreteAggregate extends Aggregate {
    private String[] ss = null;

    public ConcreteAggregate(String[] ss) {
        this.ss = ss;
    }

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

    public Object get(int index) {
        Object object = null;
        if (index < ss.length) {
            object = ss[index];
        }
        return object;
    }

    public int size() {
        return this.ss.length;
    }
}

public interface Iterator {
    public void first();
    public void next();
    public Object currentItem();
    public boolean idDone();
}

class ConcreteIterator implements Iterator {
    private int index = -1;
    private ConcreteAggregate aggregate;

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

    public void first() {
        index = 0;
    }

    public void next() {
        if (index < this.aggregate.size()) {
            index = index + 1;
        }
    }

    public Object currentItem() {
        return this.aggregate.get(index);
    }

    public boolean idDone() {
        if(index == this.aggregate.size()){
            return true;
        }
        return false;
    }
}

public class Client {
    public static void main(String[] args) {
        String[] names = {"1", "2", "3"};
        Aggregate aggregate = new ConcreteAggregate(names);
        Iterator iterator = aggregate.CreateIterator();
        iterator.first();
        while (!iterator.idDone()) {
            Object obj = iterator.currentItem();
            System.out.println(obj);
            iterator.next();
        }
    }
}

模式的优缺点

优点

  1. 它支持以不同的方式遍历一个聚合对象。

  2. 迭代器简化了聚合类。

  3. 在同一个聚合上可以有多个遍历。

  4. 在迭代器模式中,增加新的聚合类和迭代器类都很方便,无须修改原有代码。

缺点

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

思考

模式本质:控制访问聚合对象中的元素。

开发中的应用场景

  1. 访问一个聚合对象的内容而无须暴露它的内部表示。

  2. 需要为聚合对象提供多种遍历方式。

  3. 为遍历不同的聚合结构提供一个统一的接口。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容