设计模式——迭代器模式

一. 概述

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

迭代器模式为遍历不同的聚集结构提供如开始、下一个、是否结束、当前拿一项等统一的接口。

迭代器模式是最为常用的设计模式之一，在Java中已经把这个模式做在语言中，比如Java的中使用List的foreach。虽然在实际开发中基本不会主动去使用迭代器模式，但是作为对设计模式的学习也是极好的。

迭代器模式属于行为型模式。

二. UML类图解析

Iterator：迭代器接口定义，定义了遍历元素需要的方法，比如：得到下一个对象、判断是否到结尾等。
ConcerteIterator：迭代器的具体实现。
Aggregate：集合接口定义，其中定义了iterator()方法用于返回迭代器。
ConcreteAggregate：集合的具体实现。

三. 源码实现

不使用java已经有的迭代器，自己实现如下：

迭代器接口——Iterator

package io.github.brightloong.design.iterator;

/**
 * Created by BrightLoong on 2018/9/2.
 */
public interface Iterator<T> {
    /**
     * 是否有下一个.
     * @return 有下一个返回true否则返回false
     */
    boolean hasNext();

    /**
     * 返回下一个元素.
     * @return 下一个元素
     */
    T next();
}

集合接口——Aggregate

package io.github.brightloong.design.iterator;

/**
 * Created by BrightLoong on 2018/9/2.
 */
public interface Aggregate<T> {
    /**
     * 用于返回迭代器.
     * @return Iterator
     */
    Iterator iterator();

    /**
     * 获取第index元素的值，从0开始.
     * @param index 索引
     * @return T
     */
    T get(int index);

    /**
     * 获取集合的大小.
     * @return 集合大小
     */
    int size();

    /**
     * 向集合中添加元素.
     * @param t 要添加的元素
     */
    void add(T t);
}

迭代器具体实现——ConcerteIterator

package io.github.brightloong.design.iterator;

/**
 * Created by BrightLoong on 2018/9/2.
 */
public class ConcerteIterator<T> implements Iterator<T> {

    private Aggregate<T> aggregate;

    private int currentIndex = 0;


    public ConcerteIterator(Aggregate<T> aggregate) {
        this.aggregate = aggregate;
    }

    public boolean hasNext() {
        return currentIndex < aggregate.size() - 1 && aggregate.get(currentIndex) != null;
    }

    public T next() {
        return aggregate.get(currentIndex++);
    }
}

集合具体实现——ConcreteAggregate

使用数组来实现集合。

package io.github.brightloong.design.iterator;

/**
 * Created by BrightLoong on 2018/9/2.
 */
public class ConcreteAggregate<T> implements Aggregate<T> {
    /**为了方便起见，这里使用数组来实现集合*/
    private Object[] elements;

    /**上一次添加元素后，最新的一个没有元素的索引*/
    private int lastIndex = 0;

    public ConcreteAggregate(int length) {
        elements = new Object[length];
    }


    public Iterator<T> iterator() {
        return new ConcerteIterator<T>(this);
    }

    public T get(int index) {
        return (T) elements[index];
    }

    public int size() {
        return elements.length;
    }

    public void add(T t) {
        if (lastIndex >= elements.length) {
            throw new RuntimeException("out of range");
        }
        elements[lastIndex] = t;
        lastIndex++;
    }
}

客户端调用和输出

package io.github.brightloong.design.iterator;

/**
 * Created by BrightLoong on 2018/9/2.
 */
public class Client {
    public static void main(String[] args) {
        Aggregate<String> aggregate = new ConcreteAggregate<String>(5);
        aggregate.add("My");
        aggregate.add("name");
        aggregate.add("is");
        aggregate.add("BrightLoong");

        Iterator iterator = aggregate.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出结果如下

My
name
is
BrightLoong

四. 扩展——Java中的实现

要了解Java中如何实现，首先要了解Iterable接口和Iterator的差别。

Iterable，翻译过来为”可迭代的”，其中最主要的是定义了Iterator<T> iterator() 方法，类实现这个接口，表示该类具迭代功能。
Iterator，翻译过来为“迭代器”，从字面含义上就可以明确的知道，这是迭代功能的具体实现，一般在集合中，使用内部类去实现Iterator来提供迭代器的功能。接口中主要定义了一下3个方法：
```
boolean hasNext();
E next();
default void remove() {
    throw new UnsupportedOperationException("remove");
}
```

由此可以得出，Java中的迭代器的实现，基本和上面自己实现的差不多，不同的是，Java中的实现再次抽象，提取了Iterable接口。

五. 总结

使用场景

需要访问一个集合对象，而且不管这些对象是什么都需要遍历。
需要为聚合对象提供多种遍历方式。

优点

实现了迭代和集合对象解耦。
方便扩展——添加新的迭代方式或者实现新的集合类。

缺点

每实现一个集合就需要实现对应的迭代器类。