设计模式笔记（十）： 迭代器模式

迭代器概述

迭代器在Java和C++等语言中都有应用，可以说是一种很常用的设计模式，只不过很多时候，我们没有意识到这其实也算是一种设计模式，仅仅把他当做语言的特性（可能仅仅是我这样看待......）。

迭代器的作用就是遍历容器元素。如果不使用迭代器，在java里我们会这样做。

Random random = new Random();
List<Integer> integers = Stream.generate(() -> random.nextInt(10)).limit(100).collect(Collectors.toList());
for (int i = 0; i < integers.size(); i++) {
  System.out.println(integers.get(i));
}

即利用循环和索引来遍历数组。这种方式是比较原始的方式，下面是Java里使用迭代器的方式来遍历（值得注意的是，Java5之后的for-each循环最终编译后生成的使用迭代器的方式遍历）

Iterator<Integer> iterator = integers.iterator();
while (iterator.hasNext()) {
     System.out.println(iterator.next());
}

这就是Java里的迭代器，Java已经帮我们实现好了迭代器，JDK里的容器都会实现对应的迭代器，我们可以直接使用。下面我们来自动动手写一下迭代器模式。

自己实现迭代器

从Java里相关源码可以看出，要完整实现迭代器，需要以下五个部分：

1. 迭代器的抽象接口
2. 表示可迭代的接口(Iterable接口)，里面至少含有iterator()方法。
3. 容器抽象接口，继承了Iterable接口。
4. 容器的实现类，实现了容器抽象接口的类。
5. 迭代器的实现类，实现迭代器的抽象接口，一般作为容器的实现类的内部类。
   如下代码所示：

//1.
public interface Iterator<E> {

    E next();

    boolean hasNext();

    //不支持remove
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
}

//2.
public interface Iterable<E> {

    Iterator<E> iterator();
}

//3.
public interface Collection<E> extends Iterable<E> {

    void add(E e);
    void remove(E e);

}

//4.
public class MyCollection<E> implements Collection<E> {

    private List<E> list = new ArrayList<>();

    @Override
    public void add(E e) {
        list.add(e);
    }

    @Override
    public void remove(E e) {
        list.remove(e);
    }

    @Override
    public Iterator<E> iterator() {
        return new MyIterator<>(this.list);
    }

    //5.
    private class MyIterator<E> implements Iterator<E> {

        private List<E> list = new ArrayList<>();

        private int index;
        private int size;

        public MyIterator(List<E> list) {
            this.list = list;
            this.index = 0;
            this.size = this.list.size();
        }

        @Override
        public E next() {
            return hasNext() ? list.get(index++) : null;
        }

        @Override
        public boolean hasNext() {
            return index < size;
        }
    }
}

//测试类
public class Main {

    public static void main(String[] args) {
        Collection<Integer> collection = new MyCollection<>();

        for (int i = 0; i < 100; i++) {
            collection.add(i);
        }

        Iterator<Integer> iter = collection.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }


    }
}

上述代码很简单，比不少源码的完善，但基本功能算是实现了，不赘述了。

迭代器的特点

1. 封装性好，将遍历封装在迭代器内部，用户可以不用关心具体的遍历手段，用统一的接口访问即可。
2. 便利性较好，尤其是对于Map这种容器，自己写for循环遍历会比较麻烦，尤其是Java5的语法糖for-each。
3. 可以有多种遍历方式，例如正向遍历和反向遍历。
4. 对List这种有序容器来说，可能for加上索引的方式会更加好。

小结

现在可以给出迭代器模式的定义了：迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示

本系列文章参考书籍是《Head First 设计模式》，文中代码示例出自书中。