迭代器模式

定義

提供一種方法順序訪問一個聚合對象中各個元素，而又不暴露該對象的內部表示。

什麼時候用？

• 當你需要訪問一個聚集對象，而且不管這些對象是什麼都需要遍歷的時候，你就應該考慮用迭代器模式。
• 你需要對聚集有多種方式遍歷時，可以考慮用迭代器模式。

UML圖

模板代碼

Aggregate

/**
 * 聚集抽象類
 * Created by callmeDevil on 2019/8/17.
 */
public abstract class Aggregate {
    // 創建迭代器
    public abstract Iterator createIterator();
}

Iterator

/**
 * 迭代器抽象類
 * Created by callmeDevil on 2019/8/17.
 */
public abstract class Iterator {
    // 用於定義得到開始對象、得到下一對象、判斷是否到結尾、當前對象等抽象方法
    public abstract Object first();
    public abstract Object next();
    public abstract boolean isDone();
    public abstract Object currentItem();
}

ConcreteAggregate

/**
 * 具體聚集類
 * Created by callmeDevil on 2019/8/17.
 */
public class ConcreteAggregate extends Aggregate {

    // 存放聚合對象
    private List<Object> items = new ArrayList();

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

    // 返回聚集的總個數
    public int count() {
        return items.size();
    }

    // 聲明一個索引器
    public Object get(int index) {
        return items.get(index);
    }
    public boolean set(Object o) {
        return items.add(o);
    }

}

ConcreteIterator

/**
 * 具體迭代器類
 * Created by callmeDevil on 2019/8/17.
 */
public class ConcreteIterator extends Iterator {

    // 定義一個具體聚集對象
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate aggregate){
        // 初始化時將具體的聚集對象傳入
        this.aggregate = aggregate;
    }

    @Override
    public Object first() {
        // 得到聚集的第一個對象
        return aggregate.get(0);
    }

    @Override
    public Object next() {
        Object ret = null;
        current++;
        if (current < aggregate.count()) {
            // 得到聚集的下一個對象
            ret = aggregate.get(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        // 判斷當前是否遍歷到結尾
        return current >= aggregate.count();
    }

    @Override
    public Object currentItem() {
        // 返回當前的聚集對象
        return aggregate.get(current);
    }

}

測試

public class Test {
    public static void main(String[] args) {
        // 公交車聚集對象
        ConcreteAggregate a = new ConcreteAggregate();
        // 新上來的乘客
        a.set("路飛");
        a.set("鳴人");
        a.set("一護");
        a.set("悟空");
        a.set("納茲");
        a.set("琦玉");
        // 售票員登場，看好上車的是哪些人，即聲明迭代器對象
        Iterator i = new ConcreteIterator(a);
        System.out.println(String.format("車位No.1乘客：%s", i.first()));
        while (!i.isDone()){
            System.out.println(String.format("%s 來不及解釋了，快上車！", i.currentItem()));
            i.next();
        }
    }
}

測試結果

車位No.1乘客：路飛
路飛 來不及解釋了，快上車！
鳴人 來不及解釋了，快上車！
一護 來不及解釋了，快上車！
悟空 來不及解釋了，快上車！
納茲 來不及解釋了，快上車！
琦玉 來不及解釋了，快上車！

倒序遍歷

ConcreteIteratorDesc

/**
 * 倒序具體迭代器
 * Created by callmeDevil on 2019/8/17.
 */
public class ConcreteIteratorDesc extends Iterator{

    // 定義一個具體聚集對象
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIteratorDesc(ConcreteAggregate aggregate){
        // 初始化時將具體的聚集對象傳入
        this.aggregate = aggregate;
        current = aggregate.count() - 1;  //不同1
    }

    @Override
    public Object first() {
        // 得到聚集的第一個對象
        return aggregate.get(aggregate.count() - 1); //不同2
    }

    @Override
    public Object next() {
        Object ret = null;
        current--;  //不同3
        if (current >= 0) {  //不同4
            // 得到聚集的下一個對象
            ret = aggregate.get(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        // 判斷當前是否遍歷到結尾
        return current < 0;  //不同5
    }

    @Override
    public Object currentItem() {
        // 返回當前的聚集對象
        return aggregate.get(current);
    }

}

測試

將順序測試類中聲明迭代器具體對象改為倒序的 ConcreteIteratorDesc 即可。

測試結果

車位No.1乘客：琦玉
琦玉 來不及解釋了，快上車！
納茲 來不及解釋了，快上車！
悟空 來不及解釋了，快上車！
一護 來不及解釋了，快上車！
鳴人 來不及解釋了，快上車！
路飛 來不及解釋了，快上車！

總結

迭代器模式就是分離了集合對象的遍歷行為，抽象出一個迭代器類來負責，這樣既可以做到不暴露集合的內部結構，又可以讓外部代碼透明的訪問集合內部的數據。