行为型模式（四）：迭代器模式

1、模式的定义与特点

迭代器（Iterator）模式：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

迭代器模式是一种对象行为型模式，优点：
1、访问一个聚合对象的内容而无须暴露它的内部表示。
2、遍历任务交由迭代器完成，这简化了聚合类。
3、它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4、增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5、封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：
增加了类的个数，这在一定程度上增加了系统的复杂性。

2、模式的结构

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。

迭代器模式主要包含以下角色：
1、抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2、具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3、抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4、具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

图1 迭代器模式的结构图

3、模式的应用场景

1、当需要为聚合对象提供多种遍历方式时。
2、当需要为遍历不同的聚合结构提供一个统一的接口时。
3、当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

由于聚合与迭代器的关系非常密切，所以大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。

4、模式的扩展

迭代器模式常常与组合模式结合起来使用，在对组合模式中的容器构件进行访问时，经常将迭代器潜藏在组合模式的容器构成类中。
当然，也可以构造一个外部迭代器来对容器构件进行访问，其结构图如图2所示。

图2 组合迭代器模式的结构图

5、模式的实现

图3 代码结构图

抽象迭代器角色:

package com.example.designpattern.iterator;

/**
 * @author Administrator
 * @date 2020/8/5
 * 抽象迭代器角色
 */
interface Iterator {
    public boolean hasNext();

    public Object next();
}

抽象容器角色:

package com.example.designpattern.iterator;

/**
 * @author Administrator
 * @date 2020/8/5
 * 抽象容器角色
 */
interface Collection {
    public void add(Object o);

    public int size();

    public Iterator iterator();
}

具体容器角色，内含具体迭代器角色：

package com.example.designpattern.iterator;

/**
 * @author Administrator
 * @date 2020/8/5
 * 具体容器角色
 * 内部实现了具体迭代器角色（见下文注释）
 * <p>
 * 模拟数组集合
 * 使用数组来模拟集合的概念
 */
class ArrayList implements Collection {
    /**
     * 存放元素的数组，用来模拟集合
     */
    private Object[] objs = new Object[10];
    /**
     * 表示集合中元素存放的位置及个数
     */
    private int index = 0;

    /**
     * 往集合中添加元素
     */
    @Override
    public void add(Object obj) {
        //数组已经满了，应该扩展数组来模拟集合
        if (index == objs.length) {
            Object[] newObjs = new Object[objs.length + 10];
            //将旧数组中的元素拷贝到新数组的过程
            System.arraycopy(objs, 0, newObjs, 0, objs.length);
            //将旧数组对象的引用指向扩展的新数组
            objs = newObjs;
        }

        objs[index] = obj;
        index++;
    }

    /**
     * 获取集合元素的个数
     */
    @Override
    public int size() {
        return index;
    }

    @Override
    public Iterator iterator() {
        //该匿名内部类方式实现的Iterator就是具体迭代器角色
        return new Iterator() {

            int currentIndex = 0;

            @Override
            public boolean hasNext() {
                if (currentIndex >= index) {
                    return false;
                } else {
                    return true;
                }
            }

            @Override
            public Object next() {
                return objs[currentIndex++];
            }
        };
    }

}

空实现示例:

package com.example.designpattern.iterator;

/**
 * @author Administrator
 * @date 2020/8/5
 * 具体容器角色
 * 内部的Iterator实现就是具体迭代器角色（参考ArrayList）
 *
 * 模拟JDK中的类LinkedList，暂定空实现
 */
class LinkedList implements Collection {
    @Override
    public void add(Object obj) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public Iterator iterator() {
        return null;
    }
}

调用：

package com.example.designpattern.iterator;

/**
 * @author Administrator
 * @date 2020/8/5
 */
class Client {
    public static void main(String[] args) {
        // ArrayList为本例自定义类，非JDK包中的类
        //ArrayList list = new ArrayList();

        Collection list = new ArrayList();
        //Collection list = new LinkedList();

        for (int i = 0; i < 10; i++) {
            list.add(i);
        }

        System.out.println("集合元素的个数=" + list.size());

        /*
        问题：自定义的ArrayList、LinkedList等的迭代代码不统一。
        办法：将不同算法的迭代，在客户端使用时统一为Iterator类型。
         */
        Iterator it = list.iterator();

        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }

    }
}

测试结果：

图4 测试结果

6、PPT素材

微信公众号: TechU