复习：GoF的23种设计模式之iterator模式（行为型）

iterator模式（迭代器模式）

就如java集合中的iterator类似，是一种最简单也是最常用的设计模式。它可以让用户通过的特定接口轮询容器中的每一个元素，而不需要了解底层实现。

例如： 遍历一个数组

        int count = 5;
        String[] att = new String[count];
        for (int i = 0; i < count; i++) {
            System.out.println(att[i]);
        }

提问：要是我们的程序需要遍历十个、一百个不同的集合，有String类型、list类型、自定义类型等等，那么我们是否需要编写十个、一百个不同的代码吗？

人类对于处理复杂事请，早已学会分层，将复杂、重复的事请，模块化、精细化、分门别类的处理。对于我们这”一百个不同
“的程序，我们也要借鉴分层的思想。

答：对于”一百个不同程序“的遍历，我们也进行模块化处理，我们先分析题意：

用户需要遍历”一百个不同的集合“，不想重复编写代码，需要有统一的遍历措施。

“一百个不同集合“需要实现统一的某个模块，或者集合需要包含某个统一遍历措施。

对于解决这个问题，既然是统一某些东西，那么我们可以想到的是 抽象类|接口。让所有集合都实现此接口。

实例代码：

interface Iterator {
    public Boolean hasNext();
    public Object next();
}

// 所有的自定义实现类都需要实现它，即100个程序都需要继承它。
abstract class Aggregate {
    abstract Iterator createIterator();
}

class ConcreteAggregate extends Aggregate {
    private int last = 0;
    private String[] str;

    public ConcreteAggregate(int index) {
        this.str = new String[index];
    }

    public String getName(int index) {
        return str[index];
    }

    public void append(String name) {
        str[last] = name;
        last++;
    }

    public int getLast() {
        return last;
    }

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

class ConcreteIterator implements Iterator {
    private ConcreteAggregate ca;
    private int index;
    public ConcreteIterator(ConcreteAggregate ca) {
        this.ca = ca;
    }
    public Boolean hasNext() {
        return ca.getLast() > index;
    }

    public Object next() {
        return ca.getName(index);
    }
}

public class iteratorTest {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate(5);
        aggregate.append("假如一百个程序");
        System.out.println(aggregate.getName(0)+"都是不同的取元素方法");
        aggregate.append("不同的取元素方法");
        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
    }
}

假如有一百个不同的集合需要遍历，那么编写”一百个集合“都需要继承Aggregate抽象类.

我们遍历时，只需要获取Iterator类，就可以编写一段遍历代码继而重复使用。 不管集合实现如何变化，都可以使用iterator遍历元素，不依赖于aggregate实现类。

UML类图