介紹

迭代器模式是一種行為型設計模式，它是我們經常使用的一個設計模式，但是基本上不會單獨寫一個迭代器，大都使用的是 Java 語言內建的迭代器。可以說這是一個融入 Java 語言的設計模式，不止 Java ，其他很多語言都會內建這個模式。下面來看它的定義：

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

它提供一種方法訪問一個容器物件中各個元素，而又不需要暴露該物件的內部細節。

迭代器模式是一個專門服務容器的設計模式。容器只需要負責增刪元素即可，剩下的遍歷操作交給迭代器就可以了。

迭代器模式主要有四個角色：

• Iterator——抽象迭代器。
  抽象類或介面，定義迭代器的操作。

• ConcreteInterator——具體迭代器。
  實現抽象迭代器，具體實現其中的各個操作。

• Aggregate——抽象容器。
  抽象容器需要有一個可以返回迭代器的方法。

• ConcreteAggregate——具體容器。
  實現抽象容器的方法，創建出容納迭代器的物件。

模板

抽象迭代器：

public interface Iterator {
    //遍歷到下一個元素.
    public Object next();
    //是否已經遍歷到尾部。
    public
 
 boolean hasNext();
    //刪除當前指向的元素。
    public boolean remove();
}

具體迭代器：

public class ConcreteIterator implements Iterator {
    private Vector<Object> vector = new Vector<>();
    public int cursor = 0;
    public ConcreteIterator(Vector<Object> vector) {
        this.vector = vector;
    }
    @Override
 

    public boolean hasNext() {
        if (this.cursor == this.vector.size()) {
            return false;
        }
        return true;
    }
    @Override
    public Object next() {
        Object result = null;
        if (this.hasNext()) {
            result = this.vector.get(this.cursor++);
        } else {
            result = null;
        }
        return result;
    }
    @Override
    public boolean remove() {
        this.vector.remove(this.cursor);
        return true;
    }
}

抽象容器：

public interface Aggregate {
    public void add(Object object);
    public void remove(Object object);
    public Iterator iterator();
}

具體容器：

public class ConcreteAggregate implements Aggregate {
    private Vector<Object> vector = new Vector<>();
    @Override
    public void add(Object object) {
        this.vector.add(object);    
    }
    @Override
    public Iterator iterator() {
        return new ConcreteIterator(this.vector);
    }
    @Override
    public void remove(Object object) {
        this.remove(object);    
    }
}

場景類：

public class Client {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("蘋果");
        aggregate.add("橘子");
        aggregate.add("香蕉");
        Iterator iterator = aggregate.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

輸出結果：

蘋果
橘子
香蕉

總結

簡單地說，迭代器就像一個容器的遊標一樣，可以遍歷容器內部的所有元素。

如果沒有語言內建的迭代器，迭代器模式還是挺困難的一個設計模式，但是，由於大部分語言已經含有了這個模式，因此，該模式基本不會單獨出現，我們應該儘量使用語言內建的迭代器，避免自己重新搭建。