设计模式之迭代器设计模式

原文首发于微信公众号：躬行之(jzman-blog)

迭代器设计模式是一种常用的设计模式，用于提供一种方法顺序访问一个聚合对象中的各种元素，但是又不暴露该对象的内部表示，迭代器设计模式属于行为型设计模式。

1. 相关概念
2. 使用场景
3. Java实现
4. Dart实现

相关概念

• 抽象聚合角色：定义添加、删除等操作聚合对象的方法以及创建迭代器的方法；
• 具体聚合角色：抽象聚合角色的具体实现类；
• 抽象迭代器角色：定义迭代器相关方法，比如 hasNxt、first、last等方法；
• 具体迭代器角色：抽象迭代器角色的具体实现类。

使用场景

迭代器设计模式的使用场景如下：

1. 为定义的某种特定的数据结构提供遍历方式；
2. 为了隐藏聚合对象实现细节可以使用迭代器设计模式；
3. 当有多种聚合对象并存时，使用迭代器设计模式可以屏蔽这种因数据结构不同的差异；

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

迭代器设计模式虽然在遍历集合时经常用到，但是可能在使用的时候没有任何设计模式的概念，这样的概念会潜移默化的提高自己的编码能力。