java设计模式——迭代器模式(Iterator Pattern)

概述：

        在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

定义：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

结构：

•  Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
• ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
• Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
• ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

UML图：

场景：现在有一个图书馆，需要遍历其中的书籍。图书馆就是一个聚合对象。

package com.example.iteratorpattern;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * Created by **
 * 聚合类
 */

public abstract class AbstractBookList {
    protected List<Object> objects = new ArrayList<Object>();

    public AbstractBookList(List objects){
        this.objects = objects;
    }

    protected void addObject(Object object){
        this.objects.add(object);
    }

    protected void removeObject(Object object){
        this.objects.remove(object);
    }

    protected List getObjects(){
        return this.objects;
    }

    protected abstract BookIterator createIterator();
}

package com.example.iteratorpattern;

import java.util.List;

/**
 * Created by **
 */

public class BookList extends AbstractBookList {

    public BookList(List objects) {
        super(objects);
    }

    @Override
    protected BookIterator createIterator() {
        return new BookIterator(this);
    }
}

package com.example.iteratorpattern;

/**
 * Created by *8
 */

public interface AbstractIterator {
    /**
     * 移动至上一个元素
     */
    void previous();

    /**
     * 移动至下一个元素
     */
    void next();

    /**
     * 判断是否为第一个元素
     * @return
     */
    boolean isFirst();

    /**
     * 判断是否为最后一个元素
     * @return
     */
    boolean isLast();

    /**
     * 获取上一个元素
     */
    Object getNextItem();
    /**
     * 获取下一个元素
     */
    Object getPrevious();

}

package com.example.iteratorpattern;

import java.util.List;

/**
 * Created by **
 */

public class BookIterator implements AbstractIterator {

    private BookList bookList;
    private List list;
    private int cursor1;
    private int cursor2;

    public BookIterator(BookList bookList){
        this.bookList = bookList;
        this.list = bookList.getObjects();
        cursor1 = 0;
        cursor2 = this.list.size()-1;
    }
    @Override
    public void previous() {
        if (cursor2 > -1) {
            cursor2 --;
        }
    }

    @Override
    public void next() {
        if (cursor1<this.list.size()){
            cursor1 ++;
        }
    }

    @Override
    public boolean isFirst() {
        return cursor2 == -1;
    }

    @Override
    public boolean isLast() {
        return cursor1 == this.list.size();
    }

    @Override
    public Object getNextItem() {
        return this.list.get(cursor1);
    }

    @Override
    public Object getPrevious() {
        return this.list.get(cursor2);
    }
}

客户端：

List objects = new ArrayList<>();
    objects.add("阿甘正传");
    objects.add("西游记");
    objects.add("java编程思想");
    objects.add("设计模式");

    AbstractBookList bookList;
    AbstractIterator iterator;

    bookList = new BookList(objects);
    iterator = bookList.createIterator();

    logcat("正序遍历");
    logcat("first list object = "+objects.get(1));
    while (!iterator.isLast()){
        logcat(iterator.getNextItem()+",");
        iterator.next();
    }
    logcat("后序遍历");
    while (!iterator.isFirst()){
        logcat(iterator.getPrevious()+",");
        iterator.previous();
    }
}
private void logcat(String msg){
    Log.d("test",msg);
}

log输出：

12-16 17:48:49.915 11468-11468/? D/test: 正序遍历

12-16 17:48:49.915 11468-11468/? D/test: first list object = 西游记

12-16 17:48:49.915 11468-11468/? D/test: 阿甘正传,

12-16 17:48:49.915 11468-11468/? D/test: 西游记,

12-16 17:48:49.915 11468-11468/? D/test: java编程思想,

12-16 17:48:49.915 11468-11468/? D/test: 设计模式,

12-16 17:48:49.915 11468-11468/? D/test: 后序遍历

12-16 17:48:49.915 11468-11468/? D/test: 设计模式,

12-16 17:48:49.915 11468-11468/? D/test: java编程思想,

12-16 17:48:49.915 11468-11468/? D/test: 西游记,

12-16 17:48:49.915 11468-11468/? D/test: 阿甘正传,

优点：

• 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
• 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
• 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

缺点：

• 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
• 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

适用场景：

• 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
• 需要为一个聚合对象提供多种遍历方式。
• 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。

拓展：

      现有的jdk里边已经有iterable接口了，里边只有一个方法iterator()，通过该方法可以遍历聚集类的属性和方法，现在有该接口或者实现的类有：

所以我们可以直接适用现成的迭代器就行了，不需要自己去定义。

所以上面客户端的代码可以做如下修改：

List objects = new ArrayList<>();
objects.add("阿甘正传");
objects.add("西游记");
objects.add("java编程思想");
objects.add("设计模式");

logcat("正序遍历");
ListIterator listIterator = objects.listIterator();
while (listIterator.hasNext()){
    Object next = listIterator.next();
    logcat(next+" ");
}
logcat("后序遍历");
while (listIterator.hasPrevious()){
    Object previous = listIterator.previous();
    logcat(previous+" ");
}

log输出：

12-16 18:02:01.095 13345-13345/? D/test: 正序遍历

12-16 18:02:01.095 13345-13345/? D/test: 阿甘正传

12-16 18:02:01.095 13345-13345/? D/test: 西游记

12-16 18:02:01.095 13345-13345/? D/test: java编程思想

12-16 18:02:01.095 13345-13345/? D/test: 设计模式

12-16 18:02:01.095 13345-13345/? D/test: 后序遍历

12-16 18:02:01.095 13345-13345/? D/test: 设计模式

12-16 18:02:01.095 13345-13345/? D/test: java编程思想

12-16 18:02:01.095 13345-13345/? D/test: 西游记

12-16 18:02:01.095 13345-13345/? D/test: 阿甘正传