设计模式——迭代器模式

Iterator.jpg

阅读原文请访问我的博客BrightLoong's Blog

一. 概述

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

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

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

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

二. UML类图解析

Iterator.png

• 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
nameisBrightLoong

四. 扩展——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接口。

五. 总结

使用场景

• 需要访问一个集合对象，而且不管这些对象是什么都需要遍历。

• 需要为聚合对象提供多种遍历方式 。

优点

• 实现了迭代和集合对象解耦 。

• 方便扩展——添加新的迭代方式或者实现新的集合类。

缺点

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

作者：BrightLoong
链接：https://www.jianshu.com/p/217939896354