設計模型系列—迭代器模式
在現實生活以及程序設計中，經常要訪問一個聚合對象中的各個元素，如“數據結構”中的鏈表遍歷，通常的做法是將鏈表的創建和遍歷都放在同一個類中，但這種方式不利于程序的擴展，如果要更換遍歷方法就必須修改程序源代碼，這違背了 “開閉原則”。
既然將遍歷方法封裝在聚合類中不可取，那么聚合類中不提供遍歷方法，將遍歷方法由用戶自己實現是否可行呢?答案是同樣不可取，因為這種方式會存在兩個缺點：
- 暴露了聚合類的內部表示，使其數據不安全;
- 增加了客戶的負擔。
“迭代器模式”能較好地克服以上缺點，它在客戶訪問類與聚合類之間插入一個迭代器，這分離了聚合對象與其遍歷行為，對客戶也隱藏了其內部細節，且滿足“單一職責原則”和“開閉原則”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。
模式定義
提供一個對象來順序訪問聚合對象中的一系列數據，而不暴露聚合對象的內部表示。迭代器模式是一種對象行為型模式。
迭代器模式是通過將聚合對象的遍歷行為分離出來，抽象成迭代器類來實現的，其目的是在不暴露聚合對象的內部結構的情況下，讓外部代碼透明地訪問聚合的內部數據。
解決的問題
不同的方式來遍歷整個整合對象。
模式組成
使用步驟
步驟1：定義抽象迭代器角色。迭代器角色負責定義訪問和遍歷元素的接口，一般包括3個方法，即訪問下一個元素next()，元素是否已經訪問到底部hasNext()，以及刪除當前指向的元素remove()。
- interface Iterator {
- Object first();
- Object next();
- boolean hasNext();
- }
步驟2：定義具體迭代器角色。
- class ConcreteIterator implements Iterator {
- private List<Object> list = null;
- private int index = -1;
- public ConcreteIterator(List<Object> list) {
- this.list = list;
- }
- public boolean hasNext() {
- if (index < list.size() - 1) {
- return true;
- } else {
- return false;
- }
- }
- public Object first() {
- index = 0;
- Object obj = list.get(index);
- ;
- return obj;
- }
- public Object next() {
- Object obj = null;
- if (this.hasNext()) {
- obj = list.get(++index);
- }
- return obj;
- }
- }
步驟3：定義抽象聚合角色。
- interface Aggregate {
- public void add(Object obj);
- public void remove(Object obj);
- public Iterator getIterator();
- }
步驟4：定義具體聚合角色。
- class ConcreteAggregate implements Aggregate {
- private List<Object> list = new ArrayList<Object>();
- public void add(Object obj) {
- list.add(obj);
- }
- public void remove(Object obj) {
- list.remove(obj);
- }
- public Iterator getIterator() {
- return (new ConcreteIterator(list));
- }
- }
步驟5：測試
- 聚合的內容有：北京 上海 深圳
- First：北京
優點
- 訪問一個聚合對象的內容而無須暴露它的內部表示。
- 遍歷任務交由迭代器完成，這簡化了聚合類。
- 它支持以不同方式遍歷一個聚合，甚至可以自定義迭代器的子類以支持新的遍歷。
- 增加新的聚合類和迭代器類都很方便，無須修改原有代碼。
- 封裝性良好，為遍歷不同的聚合結構提供一個統一的接口。
缺點
增加了類的個數，這在一定程度上增加了系統的復雜性。
應用場景
- 當需要為聚合對象提供多種遍歷方式時。
- 當需要為遍歷不同的聚合結構提供一個統一的接口時。
- 當訪問一個聚合對象的內容而無須暴露其內部細節的表示時。
- 由于聚合與迭代器的關系非常密切，所以大多數語言在實現聚合類時都提供了迭代器類，因此大數情況下使用語言中已有的聚合類的迭代器就已經夠了。
模式的擴展
迭代器模式常常與組合模式結合起來使用，在對組合模式中的容器構件進行訪問時，經常將迭代器潛藏在組合模式的容器構成類中。當然，也可以構造一個外部迭代器來對容器構件進行訪問，其結構如下：
源碼中的應用
Java 中的容器對象有很多，基本都涉及到迭代器，我們以 ArrayList 作為例子，剖析它是如何應用迭代器模式的。
- Java集合框架：List, Set, Map 都支持迭代
ArrayList 源碼可以發現：
- ArrayList 實現了 List 接口，使用 Object 數組存儲元素;
- 在 List 接口中定義了 iterator() 以及很多對操作集合的方法;
- 在 ArrayList 中對 iterator() 進行了重寫，并返回一個 Itr 對象;
- Itr 是 ArrayList 的內部類，并且實現了 Iterator 接口。
部分源碼展示
List接口
- public interface List<E> extends Collection<E> {
- Iterator<E> iterator();
- }
Iterator接口
- public interface Iterator<E> {
- boolean hasNext();
- E next();
- default void remove() {
- throw new UnsupportedOperationException("remove");
- }
- }
ArrayList類和Itr類
- public class ArrayList<E> extends AbstractList<E>
- implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
- public Iterator<E> iterator() {
- return new Itr();
- }
- //Itr內部類
- private class Itr implements Iterator<E> {
- int cursor; // index of next element to return
- int lastRet = -1; // index of last element returned; -1 if no such
- int expectedModCount = modCount;
- public boolean hasNext() {
- return cursor != size;
- }
- @SuppressWarnings("unchecked")
- public E next() {
- checkForComodification();
- int i = cursor;
- if (i >= size)
- throw new NoSuchElementException();
- Object[] elementData = ArrayList.this.elementData;
- if (i >= elementData.length)
- throw new ConcurrentModificationException();
- cursor = i + 1;
- return (E) elementData[lastRet = i];
- }
- public void remove() {
- if (lastRet < 0)
- throw new IllegalStateException();
- checkForComodification();
- try {
- ArrayList.this.remove(lastRet);
- cursor = lastRet;
- lastRet = -1;
- expectedModCount = modCount;
- } catch (IndexOutOfBoundsException ex) {
- throw new ConcurrentModificationException();
- }
- }
- @Override
- @SuppressWarnings("unchecked")
- public void forEachRemaining(Consumer<? super E> consumer) {
- Objects.requireNonNull(consumer);
- final int size = ArrayList.this.size;
- int i = cursor;
- if (i >= size) {
- return;
- }
- final Object[] elementData = ArrayList.this.elementData;
- if (i >= elementData.length) {
- throw new ConcurrentModificationException();
- }
- while (i != size && modCount == expectedModCount) {
- consumer.accept((E) elementData[i++]);
- }
- // update once at end of iteration to reduce heap write traffic
- cursor = i;
- lastRet = i - 1;
- checkForComodification();
- }
- final void checkForComodification() {
- if (modCount != expectedModCount)
- throw new ConcurrentModificationException();
- }
- }
- }
PS：以上代碼提交在 Github ：
https://github.com/Niuh-Study/niuh-designpatterns.git
