设计模式－迭代器模式

###模式定义

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

###模式结构

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. 为遍历不一样的聚合结构提供一个统一的接口。