Java设计模式 迭代器模式

概述

可以存储多个成员对象（元素），这些类通常称为聚合类（Aggregate
Classes），对应的对象称为聚合对象。为了更加方便地操作这些聚合对象，同时可以很灵活地为聚合对象增加不同的遍历方法，可以访问一个聚合对象中的元素但又不需要暴露它的内部结构。这就是接下来我们将要学习的迭代器模式，通过引入迭代器，客户端无须了解聚合对象的内部结构即可实现对聚合对象中成员的遍历，还可以根据需要很方便地增加新的遍历方式。
在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

定义

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

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

实现

public interface Aggregate<T> {
    void add(T t);
    void remove();
    Iterator<T> createIterator();
}

public interface Iterator<T> {
    T first();
    T next();
    boolean hasNext();
    T currentItem();
}

public class ArrayAggregate<T> implements Aggregate<T> {

    private final int MAX_SIZE = 1000;

    private Object[]  objs;

    private int index = -1;

    public ArrayAggregate() {
        objs = new Object[MAX_SIZE];
    }

    @Override
    public void add(T t) {
        if (index < objs.length-1) {
            objs[++index] =t;
        } else {
            throw new RuntimeException("数组已经满了！");
        }
    }

    @Override
    public void remove() {
        if (index >= 0) {
            index--;
        } else {
            throw new RuntimeException("数组已经空了！");
        }
    }

    @Override
    public Iterator<T> createIterator() {
        return new Itr();
    }

    public class Itr implements Iterator<T> {

        private int cursor = -1;

        @Override
        public T first() {
            if (index >= 0) {
                throw new RuntimeException("这是一个空数组！");
            } else {
                return (T)objs[0];
            }
        }

        @Override
        public T next() {
            if (hasNext()) {
                return (T) objs[++cursor];
            } else {
                throw new RuntimeException("没有下一个了！");
            }
        }

        @Override
        public boolean hasNext() {
            return cursor < index;
        }

        @Override
        public T currentItem() {
            if (cursor < 0 && cursor > index) {
                throw new RuntimeException("当前不存在！！");
            }
            return (T) objs[cursor] ;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Aggregate<Integer> list = new ArrayAggregate<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        ArrayAggregate.Itr itr = (ArrayAggregate.Itr) list.createIterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }
}

输出：12345

优点和缺点

优点：

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

缺点：

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