設計模式之迭代器模式

迭代器模式：在不暴露一個聚合對象的內部表示的情況下，提供一種方法來按順序訪問該對象中的各個元素。

抽象出一個聚合類，該類提供一個方法iterator()返回這個聚合類對應的迭代器：

public interface Aggregate<T> {
    Iterator<T> iterator();

    void add(T t);

    void remove(T t);
}

迭代器抽象類，可以抽象出hasNext()和next()方法，供子類去實現不同的迭代方式，並定義一個默認序號：

public abstract class Iterator<T> {
    int index = -1;

    abstract T first();

    abstract T next();

    abstract boolean hasNext();
}

具體聚合類，繼承父接口重寫iterator()返回迭代器，內部保存一個容器，向外提供添加和刪除元素的方法：

public class ConcreteAggregate implements Aggregate<String> {
    List<String> lists = new ArrayList<>();

    @Override
    public Iterator<String> iterator() {
        return new ForwardIterator(this);
//        return new BackwardIterator(this);
    }

    @Override
    public void add(String s) {
        lists.add(s);
    }

    @Override
    public void remove(String s) {
        lists.remove(s);
    }
}

正序迭代器，構造方法傳入一個對應的聚合類，重寫獲取元素的幾個方法：

public class ForwardIterator extends Iterator<String> {
    private ConcreteAggregate target;

    public ForwardIterator(ConcreteAggregate target) {
        this.target = target;
    }

    @Override
    public String first() {
        return target.lists.get(0);
    }

    @Override
    public String next() {
        return target.lists.get(++index);
    }

    @Override
    public boolean hasNext() {
        int tempIndex = index + 1;
        return tempIndex < target.lists.size();
    }
}

使用迭代器去遍歷聚合類：

public class Main {
    public static void main(String[] args) {
        final ConcreteAggregate concreteTarget = new ConcreteAggregate();
        for (int i = 0; i < 10; i++) {
            concreteTarget.add("Item " + i);
        }

        final Iterator<String> iterator = concreteTarget.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

倒敘迭代器的實現，迭代器的切換只要在ConcreteAggregate類中iterator()返回不同的迭代器即可。

public class BackwardIterator extends Iterator<String> {
    private ConcreteAggregate target;

    public BackwardIterator(ConcreteAggregate target) {
        this.target = target;
        index = this.target.lists.size();
    }

    @Override
    String first() {
        final int size = target.lists.size();
        return size > 0 ? target.lists.get(size - 1) : null;
    }

    @Override
    String next() {
        return target.lists.get(--index);
    }

    @Override
    boolean hasNext() {
        final int tempIndex = index - 1;
        return tempIndex >= 0;
    }
}

迭代器模式的好處在於把遍歷行爲抽離了出來，屏蔽了內部實現，也提供了良好的擴展性。