01_迭代器模式

转载自潘威威的 设计模式（16）-迭代器模式，局部略有调整。

1. 简介

1.1 为什么要使用迭代器模式？

在软件设计中，我们常用聚合对象来存储和遍历数据。存储和遍历是两个职责，如果都放在聚合对象中，就违反了“单一职责原则”。迭代器模式就是为解决这个问题而产生的。
迭代器模式将遍历的职责从聚合对象中剥离出来，放在一个称为迭代器的类中，使其更符合“单一职责原则”。

1.2 什么是迭代器模式？

迭代器模式（Iterator Pattern）: 提供一种方法来访问聚合对象中的各个元素，而不用暴露这个对象的内部表示。

1.3 别名

游标（Cursor）

1.4 遵守的原则

单一职责原则、开闭原则

使用频率

★★★★★

2. 构成

• Iterator ：抽象迭代器

  • 抽象类
  • 具体迭代器的父类
  • 定义访问和遍历元素的接口

• ConcreteIterator

  • 具体了
  • 继承抽象迭代器
  • 实现访问和遍历元素的方法
  • 对该聚合对象遍历时跟踪当前位置

• Aggregate ：抽象聚合类

  • 聚合类
  • 存储和管理元素对象
  • 定义创建相应迭代器对象的接口，充当抽象迭代器工厂角色

• ConcreteAggregate ：具体聚合类

  • 具体类
  • 集成抽象聚合类
  • 实现Aggragate的方法，创建ConcreteIterator对象。

2.1 UML类图

2.2 实现

1. 抽象聚合类 Aggregate.java

    interface Aggregate {
    Iterator createIterator();
}

1. 具体聚合类 ConcreteAggregate.java

class ConcreteAggregate implements Aggregate {

    //在这里，根据实际情况定义要存储的数据

    public ConcreteIterator createIterator() {
        return new ConcreteIterator(this);
    }
}

1. 抽象迭代器 Iterator.java

interface Iterator {
    public void first();

    public void next();

    public boolean hasNext();

    public Object currentItem();
}

1. 具体迭代器 ConcreteIterator.java

class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate; // 维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
    private int cursor; // 定义一个游标，用于记录当前访问位置

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    public void first() {
        //根据实际情况实现方法
    }

    public void next() {
        //根据实际情况实现方法

    }

    public boolean hasNext() {
        //根据实际情况实现方法
        return false;
    }

    public Object currentItem() {
        //根据实际情况实现方法
        return null;
    }
}

1. 客户类（测试类）

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        ConcreteIterator iterator = aggregate.createIterator();
        iterator.first();
    }
}

2.3 优缺点

1. 优点
   
   • 遵守“单一职责原则”。将聚合类的遍历职责剥离出来，使聚合类遵守“单一职责原则”
   • 遵守“开闭原则”。由于抽象聚合类和抽象迭代器类，添加新的聚合类和迭代器都不需要修改原代码。（对扩展开放，对修改关闭）
   • 支持以不同的遍历算法遍历聚合对象，只要用心的迭代器替换就可以。
2. 缺点
   。。

2.4 适用环境

• 访问一个聚合对象的内容，而不想暴露其内部。
• 为聚合对象，提供多种遍历方式
• 为遍历不同的聚合对象提供一个统一的接口，且可以有不同的迭代实现，为客户端可以一致性的调用遍历操作。

2.5 java8中的Iterator迭代器

• Iterator.java 作为抽象迭代器
• Collection.java 继承Iterator.java (Collection 是一个抽象接口)
• ArrayList.java等容器实现Collection.java,作为聚合类，其中包含获取迭代器的方法iterator()

抽象迭代器Iterator.java

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /*
    1.8版本新增的，针对lambda表达式的方法
    */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

集合容器 Collection.java

package java.util;  

public interface Collection<E> extends Iterable<E> {  
    ……  
    Iterator iterator();  
    ……  
}  

ArrayList 迭代器的具体实现

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     * 返回一个迭代器
     * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     * 返回的迭代器是快速失败的（fail-fast）
     * @return an iterator over the elements in this list in proper sequence
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * An optimized version of AbstractList.Itr
     * 具体迭代器的实现
     * 迭代器的遍历顺序是顺序执行的。
     */
    private class Itr implements Iterator<E> {
        int cursor;       //  next()方法返回元素的下标
        int lastRet = -1; // 上一个元素的下标
        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];
    }

    ......
    }

思考：(E) elementData[lastRet = i];写法有什么有点？
使用demo

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Created by Administrator on 2018/3/7.
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> strArrayList = new ArrayList<>();
        strArrayList.add("1");
        strArrayList.add("2");
        strArrayList.add("3");
        strArrayList.add("4");
        //获得迭代器实例
        Iterator iterator = strArrayList.iterator();
        //迭代
        while (iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }
}

2.6 扩展

相关模式
- 组合模式Composite: 迭代器常备应用到像复合这样的递归结构上
- 工厂方法模式Factory Method ：多态迭代器靠Facotry Method来例化适当的迭代器子类。
- 备忘录模式Memento：常与迭代器模式一起使用。迭代器可以使用memento捕获一个迭代的状态。迭代器在其内部存储memento。