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

原文首发于微信公众号:躬行之(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

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

©️2020 CSDN 皮肤主题: 我行我“速” 设计师:Amelia_0503 返回首页