设计模式——迭代器模式原理及代码实现

一、简介

        迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露该对象的内部表示。

二、结构图

三、代码实现

1.Iterator

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

 2.ConcreteIterator

public class ConcreteIterator<T> implements Iterator{

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

    private ConcreteAggregate<T> aggregate;
    private int count = 0;

    @Override
    public T first() {
        return aggregate.get(0);
    }

    @Override
    public T next() {
        T element = null;
        if (count < aggregate.count()) {
            element = aggregate.get(count);
            count++;
        }
        return element;
    }

    @Override
    public boolean isDone() {
        return count >= aggregate.count();
    }

    @Override
    public Object currentItem() {
        return aggregate.get(count);
    }
}

3.Aggregate

public interface Aggregate<T> {
    Iterator createIterator();
}

4.ConcreteAggregate

public class ConcreteAggregate<T> implements Aggregate{

    private List<T> items = new ArrayList<>();

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

    public int count() {
        return items.size();
    }

    public T get(int index) {
        return items.get(index);
    }

    public void add(T t) {
        items.add(t);
    }
}

5.Client

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate<Integer> aggregate = new ConcreteAggregate<>();
        aggregate.add(0);
        aggregate.add(3);
        aggregate.add(7);

        Iterator<Integer> iterator = aggregate.createIterator();
        while (!iterator.isDone()) {
            int next = iterator.next();
            System.out.println(next);
        }
    }
}

四、总结

1. 迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部地数据。
2. 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类。