设计模式-迭代器模式

迭代器模式

设计模式介绍

在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的 API 完全够用。

定义

提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示。

优点

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

应用场景

• 当需要为聚合对象提供多种遍历方式时。
• 当需要为遍历不同的聚合结构提供一个统一的接口时。
• 当访问一个聚合对象的内容而无须暴露其内部细节的表示时
• 组合模式中 需要遍历树枝构件时

设计模式结构与实现

结构

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

模板实现

实现一个可以装所有对象的集合，然后隐藏它，只向外提供迭代器来遍历其中对象~

package behaviour.iterator;

import java.util.ArrayList;
import java.util.List;

/**
 * 抽象聚合
 */
interface Aggregate {
    /**
     * 为集合添加元素
     *
     * @param obj 添加的元素
     */
    void add(Object obj);

    /**
     * 为集合移除元素
     *
     * @param obj 要移除的元素
     */
    void remove(Object obj);

    /**
     * 获取该集合的迭代器
     *
     * @return 该集合的迭代器
     */
    Iterator getIterator();
}

/**
 * 具体聚合:一个可以装各种对象的集合列表
 */
class ConcreteAggregate implements Aggregate {
    private final List<Object> list = new ArrayList<>();

    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator getIterator() {
        return (new ConcreteIterator(list));
    }
}

/**
 * 抽象迭代器
 */
interface Iterator {
    /**
     * 获取首个元素，并将迭代器遍历下标重置为0
     *
     * @return 首个元素对象
     */
    Object first();

    /**
     * 遍历下标+1 并获取该下标对应的对象
     * 下标默认为-1，因此第一次调用时 下标+1 = 0 正好可以获取首个对象
     *
     * @return 下一个元素对象
     */
    Object next();

    /**
     * 检索当前是否遍历完集合，是否还可以继续遍历
     *
     * @return 是否还可以继续遍历集合
     */
    boolean hasNext();
}

/**
 * 具体迭代器
 */
class ConcreteIterator implements Iterator {
    private final List<Object> list;
    /**
     * index 默认为-1 ！！ 因此首次next()可以直接获取list.get(0)首元素
     */
    private int index = -1;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return index < list.size() - 1;
    }

    @Override
    public Object first() {
        return list.get(index = 0);
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = list.get(++index);
        }
        return obj;
    }
}

public class IteratorTemplateClient {
    public static void main(String[] args) {
        Aggregate ag = new ConcreteAggregate();
        ag.add("字符串");
        ag.add(ag);
        ag.add(ag.getIterator());
        System.out.println("聚合的内容有：");
        Iterator it = ag.getIterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println("\t" + obj.toString());
        }
        System.out.println("调用first()");
        Object first = it.first();
        System.out.println("\t" + first.toString());
    }
}

运行结果

聚合的内容有：
	字符串
	behaviour.iterator.ConcreteAggregate@1b6d3586
	behaviour.iterator.ConcreteIterator@4554617c
调用first()
	字符串