软件设计模式学习（二十）迭代器模式

迭代器模式是一种使用频率很是高的设计模式，迭代器用于对一个聚合对象进行遍历。经过引入迭代器能够将数据的遍历功能从聚合对象中分离出来，聚合对象只负责存储数据，聚合对象只负责存储数据，而遍历数据由迭代器来完成。

模式动机

一个聚合对象，如一个列表（List）或者一个集合（Set）,应该提供一种方法来让别人能够访问它的元素，而又不须要暴露它的内部结构。此外，针对不一样的须要，可能还要以不一样方式遍历整个聚合对象，可是咱们不希在聚合对象的抽象层接口中充斥着各类不一样遍历的操做。怎样遍历一个聚合对象，又不须要了解聚合对象的内部结构，还能提供多种不一样的遍历方式，这就是迭代器模式所要解决的问题。

迭代器模式中，提供一个外部的迭代器来对聚合对象进行访问和遍历，迭代器定义一个访问该聚合元素的接口，而且能够跟踪当前遍历对象，了解哪些元素已经遍历过而哪些没有。

模式定义

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

模式结构

1. Iterator（抽象迭代器）

   抽象迭代器定义了访问和遍历元素的接口，通常声明如下方法：

   • 用于获取第一个元素的 first()
   • 用于访问下一个元素的 next()
   • 用于判断是否还有下一个元素的 hasNext()
   • 用于获取当前元素的 currentItem()

2. ConcreteIterator（具体迭代器）

   具体迭代器实现了抽象迭代器接口，完成对聚合对象的遍历，同时在对聚合进行遍历时跟踪其当前位置

3. Aggregate（抽象聚合类）

   抽象聚合类用于存储对象，并定义建立相应迭代器对象的接口，声明一个 createIterator() 方法用于建立一个迭代器对象

4. ConcreteAggregate（具体聚合类）

   具体聚合类实现了建立相应迭代器的接口，实现了在聚合类中声明的 createIterator() 方法，该方法返回一个与具体聚合对应的具体迭代器 ConcreteIterator 实例

模式分析

存储数据是聚合对象的最基本职责，其中包含存储数据的类型、存储空间的大小、存储空间的分配，以及存储的方式和顺序。然而，聚合对象除了能存储数据外，还必须提供遍历访问其内部数据的方式，同时这些遍历方式可能会根据不一样的情形提供不一样的实现。

所以，聚合对象主要有两个职责：一是存储内部数据；二是遍历内部数据。前者是聚合对象的基本功能，后者是能够分离的。根据单一职责原则，对象承担的职责越少，对象的稳定性就越好，咱们将遍历聚合对象中数据的行为提取出来，封装到一个迭代器中，经过专门的迭代器来遍历聚合对象的内部数据。迭代器模式是单一职责原则的完美体现。

下面经过一个简单的自定义迭代器来分析迭代器模式的结构

首先定义一个简单的迭代器去接口

public interface MyIterator {
    void first();	// 访问第一个元素
    void next();	// 访问下一个元素
    boolean isLast();	// 判断是不是最后一个元素
    Object currentItem();	// 获取当前元素
}

而后须要定义一个聚合接口

public interface MyCollection {
    // 返回一个 MyIterator 迭代器对象
    MyIterator createIterator();
}

定义好抽象层以后，咱们须要定义抽象迭代器接口和抽象聚合接口的实现类，通常将具体迭代器类做为具体聚合类的内部类，从而迭代器能够实现直接访问聚合类中的数据

public class NewCollection implements MyCollection {
    
    private Object[] obj = {"dog", "pig", "cat", "monkey", "pig"};
    
    public MyIterator createIterator() {
        return new NewIterator();
    }
    
    private class NewIterator implements MyIterator {
        
        private int currentIndex = 0;
        
        public void first() {
            currentIndex = 0;
        }
        
        public void next() {
            if(currentIndex < obj.length) {
                currentIndex++;
            }
        }
        
        public boolean isLast() {
            return currentIndex == obj.length;
        }
        
        public void currentItem() {
            return obj[currentIndex];
        }
    }     
}

NewCollection 类实现了 MyCollection 接口，实现了 createIterator() 方法，同时定义了一个数组用于存储数据元素，还定义了一个实现了 MyIterator 接口的内部类，索引变量 currentIndex 用于保存所操做的数组元素的下标值。客户端代码以下：

public class Client {
    
    public static void process(MyCollection collection) {
        MyIterator i = collection.createIterator();
        while(!i.isLast()) {
            System.out.println(i.currentItem().toString());
            i.next();
        }
    }
    
    public static void main(String args[]) {
        MyCollection collection = new NewCollection();
        process(collection);
    }
}

除了使用内部类实现以外，也可使用常规的方式来实现迭代器

public class ConcreteIterator implements Iterator {
    
    private ConcreteAggregate objects;
    
    public ConcreteIterator(ConcreteAggregate objects) {
        this.objects = objects;
    }
    
    public void first() {
        ...
    }
        
    public void next() {
        ...
    }
        
    public boolean isLast() {
        ...
    }
        
    public void currentItem() {
        ...
    }
}

public class ConcreteAggregate implements Aggregate {
    ...
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
}

迭代器模式中应用了工厂方法模式，聚合类充当工厂类，而迭代器充当产品类

模式优缺点

迭代器模式优势：

1. 支持以不一样的方式遍历一个聚合对象。在迭代器模式中只须要用一个不一样的迭代器来替换原有迭代器便可改变遍历算法，也能够本身定义迭代器的子类以支持新的遍历方式。
2. 迭代器简化了聚合类。原有聚合对象再也不须要自行提供遍历数据等操做方法。
3. 在同一个聚合上能够有多个遍历。因为每一个迭代器都保持本身的遍历状态，所以能够对一个聚合对象进行多个遍历操做。
4. 增长新的聚合类和迭代器类都很方便，无须修改原代码，知足开闭原则。

迭代器模式缺点：

1. 因为迭代器模式将存储数据和遍历数据的职责分离，增长新的聚合类须要对应增长新的迭代器类，类的个数成对增长，在必定程度上增长了系统的复杂性

模式适用环境

在如下状况可使用迭代器模式：

1. 访问一个聚合对象的内容而无须暴露它的内部表示
2. 须要为聚合对象提供多种遍历方式
3. 为遍历不一样的聚合结构提供一个统一的接口

Java 迭代器

Java 中的集合框架 Collections，其基本接口层次结构如图

Collection 是全部集合类的根接口，它的主要方法以下：

boolean add(Object c);
boolean addAll(Collection c);
boolean remove(Object o);
boolean removeAll(Collection c);
boolean remainAll(Collection c);
Iterator iterator();

Collection 的 iterator() 方法返回一个 java.util.Iterator 类型的对象，而其子接口 java.util.List 的 listIterator() 方法返回一个 java.util.ListIterator 类型的对象，ListIterator 是 Iterator 的子类，它们构成了 Java 语言对迭代器模式的支持。

在 JDK 中，Iterator 接口具备以下三个基本方法：

1. Object next()：经过反复调用 next() 方法能够逐个访问聚合中的元素
2. boolean hasNext()：用于判断聚合对象在是否还存在下一个元素，为了避免抛出异常，必须在调用 next() 以前先调用 hasNext()。若是迭代对象仍然拥有可供访问的元素，那么 hasNext() 返回 true
3. void remove()：删除上一次调用 next() 时返回的元素

Java 迭代器能够理解为它工做时在聚合对象的各个元素之间，每调用一次 next() 方法，迭代器便越过下个元素，而且返回它刚越过的那个元素的地址引用。

在第一个 next() 方法被调用时，迭代器由“元素1”与“元素2”之间移动至“元素2”与“元素3”之间，跨越了“元素2”，所以 next() 方法将返回对“元素2”的引用；在第二个 next() 方法被调用时，迭代器由“元素2”与“元素3”之间移至“元素3”与“元素4”之间，next() 方法将返回对“元素3”的引用，此时调用 remove() 方法，则可将”元素3“删除。

须要注意的是，next() 方法与 remove() 方法的调用是相互关联的。若是调用 remove() 以前没有先对 next() 进行调用，那么将抛出异常，由于没有任何可供删除的元素