迭代器設計模式

PS：任何美好的事情當變得習以為常的時候都會變得不再珍貴。

迭代器設計模式是一種常用的設計模式，用於提供一種方法順序訪問一個聚合對象中的各種元素，但是又不暴露該對象的內部表示，迭代器設計模式屬於行為型設計模式。

相關概念
使用場景
Java 實現
Dart 實現

使用場景#

迭代器設計模式的使用場景如下：

為定義的某種特定的數據結構提供遍歷方式；
為了隱藏聚合對象實現細節可以使用迭代器設計模式；
當有多種聚合對象並存時，使用迭代器設計模式可以屏蔽這種因數據結構不同的差異；

Java 實現#

簡單實現一下迭代器設計模式，定義抽象聚合角色如下：

/**
 * 抽象聚合角色
 * Created by jzman
 * Powered by 2019/12/22.
 */
interface Aggregate {
    Iterator createIterator();
}

定義抽象迭代器角色如下：

/**
 * 抽象迭代器角色
 * Created by jzman
 * Powered by 2019/12/22.
 */
interface Iterator {
    Object first();
    Object next();
    boolean isDone();
    Object currentItem();
}

實現具體的聚合角色和具體的迭代器角色如下：

/**
 * 具體的聚合角色
 * Created by jzman
 * Powered by 2019/12/22.
 */
class ConcreteAggregate implements Aggregate {
    private List<Object> mList;
    
    public ConcreteAggregate(List<Object> mList) {
        this.mList = mList;
    }
    
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator();
    }

    /**
     * 具體的迭代器角色
     */
    private class ConcreteIterator implements Iterator {

        private int mCursor;

        @Override
        public Object first() {
            return mList.get(0);
        }

        @Override
        public Object next() {
            mCursor++;
            if (mCursor < mList.size()) {
                return mList.get(mCursor);
            }
            return null;
        }

        @Override
        public boolean isDone() {
            return mCursor >= mList.size();
        }

        @Override
        public Object currentItem() {
            return mList.get(mCursor);
        }
    }
}

測試上述代碼：

/**
 * 迭代器測試
 * Created by jzman
 * Powered by 2019/12/22.
 */
class Client {
    public static void main(String[] args) {
        List<Object> objects = new ArrayList<>();
        objects.add("A");
        objects.add("B");
        objects.add("C");
        ConcreteAggregate aggregate = new ConcreteAggregate(objects);

        // 獲取迭代器
        Iterator iterator = aggregate.createIterator();
        // 遍歷
        while (!iterator.isDone()) {
            Object o = iterator.currentItem();
            System.out.println("data:" + o);
            iterator.next();
        }
    }
}

測試結果如下：

data:A
data:B
data:C

Dart 實現#

main(){
  List<Object> mList = ["A","B","C"];
  Aggregate aggregate = new ConcreteAggregate(mList);
  Iterator iterator = aggregate.createIterator();
  while (!iterator.isDone()) {
    Object obj = iterator.currentItem();
    print("data：${obj.toString()}");
    iterator.next();
  }
}

// 抽象迭代器角色
abstract class Iterator{
  Object first();
  Object next();
  bool isDone();
  Object currentItem();
}

//具體迭代器角色
class ConcreteIterator implements Iterator{
  int mCursor = 0;
  List<Object> mList;

  ConcreteIterator(this.mList);

  @override
  Object first() {
      return mList[0];
  }

  @override
  Object next() {
      mCursor++;
      if (mCursor < mList.length) {
          return mList[mCursor];
      }
      return null;
  }

  @override
  bool isDone() {
      return mCursor >= mList.length;
  }

  @override
  Object currentItem() {
      return mList[mCursor];
  }
}

// 抽象聚合角色
abstract class Aggregate {
  Iterator createIterator();
}

// 具體聚合角色
class ConcreteAggregate implements Aggregate{
  List<Object> mList;
  ConcreteAggregate(this.mList);
  @override
  Iterator createIterator(){
    return new ConcreteIterator(mList);
  }
}

測試效果如下：

data：A
data：B
data：C

迭代器設計模式雖然在遍歷集合時經常用到，但是可能在使用的時候沒有任何設計模式的概念，這樣的概念會潛移默化的提高自己的編碼能力。

迭代器設計模式

相關概念#

使用場景#

Java 實現#

Dart 實現#