迭代器模式

定义

提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节。

Iterator：抽象迭代器，负责定义访问和遍历元素的接口，基本上是固有的三个方法：first()获得第一个元素，next()访问下一个元素，hasNext()是否已经访问到底部。
ConcreteIterator：具体迭代器，实现迭代器接口，完成容器元素的遍历。
Aggregate：抽象容器，容器角色负责创建具体迭代器角色的接口，提供一个类似于createIterator()这样的方法。
ConcreteAggregate：具体容器，实现容器接口定义的方法，创建出容纳迭代器的对象。

具体实现

抽象迭代器：

public interface Iterator<T> {
    T next();

    boolean hasNext();

    boolean remove();
}

迭代器实现：

public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> list;
    /**
     * 定义当前游标
     */
    public int cursor = 0;

    public ConcreteIterator(List<T> list){
        this.list = list;
    }

    @Override
    public T next() {
        T result = null;
        if (this.hasNext()){
            result = this.list.get(this.cursor++);
        }
        return result;
    }

    @Override
    public boolean hasNext() {
        return this.cursor != this.list.size();
    }

    @Override
    public boolean remove() {
        this.list.remove(this.cursor);
        return true;
    }
}

抽象容器：

public interface Aggregate<T> {
    void add(T object);

    void remove(T object);

    Iterator iterator();
}

具体容器：

public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> list = new ArrayList<T>();
    @Override
    public void add(T object) {
        this.list.add(object);
    }

    @Override
    public void remove(T object) {
        this.list.remove(object);
    }

    @Override
    public Iterator iterator() {
        return new ConcreteIterator<T>(this.list);
    }
}

测试main方法：

public class Main {

    public static void main(String[] args) {
        // 声明容器
        Aggregate<String> aggregate = new ConcreteAggregate<String>();
        aggregate.add("abc");
        aggregate.add("123");
        aggregate.add("sds");
        // 遍历
        Iterator<String> iterator = aggregate.iterator();
        System.out.println(iterator.hasNext());
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
// 输出
true
abc
123
sds

优点

访问一个聚合对象的内容而无须暴露它的内部表示。
遍历任务交由迭代器完成，这简化了聚合类。
它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
增加新的聚合类和迭代器类都很方便，无须修改原有代码。
封装性良好，为遍历不同的聚合结构提供一个统一的接口。

应用

从JDK1.2版本开始增加java.util.Iterator接口，并逐步把Iterator应用到各个聚集类(Collection)中，所以基本上不需要手写迭代器的。

代码：Github

欢迎关注公众号：
公众号微信