设计模式 之 迭代器模式（Iterator）

1、简介

**定义：**提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。所谓聚合是指一组对象的组合结构，比如:Java 中的集合、数组等。聚合对象拥有两个职责：一是存储数据，二是遍历数据。可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。这样一来，不同的迭代器可以对同一个聚合对象进行不同的遍历方式。迭代器模式在JAVA的很多集合类中被广泛应用。

2、迭代器的结构说明

• 抽象迭代器（Iterator）: 定义访问和遍历元素的接口。
• 具体的选代器（ConcreteIterator）: 实现对聚合对象的遍历，并跟踪遍历时的当前位置。
• 抽象聚合对象（AbstractAggregate）: 定义聚合对象的相关操作的（增删改）接口，并提供创建相应迭代器对象的接口。
• 具体聚合对象（ConcreteAggregate）: 具体的聚合对象，并提供具体的迭代器实现。

3、迭代器代码实现

/**
 * @Author dw
 * @ClassName AbstractAggregate
 * @Description 抽象聚合对象
 * @Date 2023/12/20 11:07
 * @Version 1.0
 */
public abstract class AbstractAggregate {

    /**
     * 获取元素个数
     * @return int
     */
    protected abstract int size();
    /**
     * 聚合对象的新增
     * @return true
     */
    protected abstract boolean add();
    /**
     * 聚合对象的删除
     * @return true
     */
    protected abstract boolean remove();

    /**
     * 获取迭代器
     *
     * @return true
     */
    protected abstract Iterator iterator();
}


/**
 * @Author dw
 * @ClassName ConcreteAggregate
 * @Description 具体聚合对象
 * @Date 2023/12/20 11:07
 * @Version 1.0
 */
public class ConcreteAggregate extends AbstractAggregate {

    /**
     * 表示具体的聚合数据
     */
    protected Object[] arr = {};

    /**
     * 获取元素个数
     *
     * @return int
     */
    @Override
    protected int size() {
        return arr.length;
    }

    /**
     * 聚合对象的新增
     *
     * @return true
     */
    @Override
    protected boolean add() {
        // ...
        return true;
    }

    /**
     * 聚合对象的删除
     *
     * @return true
     */
    @Override
    protected boolean remove() {
        // ...
        return true;
    }

    /**
     * 获取迭代器
     *
     * @return true
     */
    @Override
    protected Iterator iterator() {
        return new ConcreteIterator(this);
    }
}


/**
 * @Author dw
 * @ClassName Iterator
 * @Description 抽象迭代器
 * @Date 2023/12/20 11:06
 * @Version 1.0
 */
public interface Iterator {

    /**
     * 是否存在下一个元素
     * @return true|false
     */
    public boolean hasNext();

    /**
     * 获取下一个元素
     * @return 下一个元素
     */
    public Object next();
}


/**
 * @Author dw
 * @ClassName ConcreteIterator
 * @Description 具体的选代器
 * @Date 2023/12/20 11:06
 * @Version 1.0
 */
public class ConcreteIterator implements Iterator{
    /**
     * 持有被迭代的具体的聚合对象
     */
    private final ConcreteAggregate concreteAggregate;

    /**
     * 记录被迭代的索引
     */
    private int index = 0;

    /**
     * 传入需要被迭代的对象
     * @param concreteAggregate
     */
    public ConcreteIterator (ConcreteAggregate concreteAggregate) {
        this.concreteAggregate = concreteAggregate;
    }

    /**
     * 是否存在下一个元素
     */
    @Override
    public boolean hasNext() {
        return index < concreteAggregate.size();
    }

    /**
     * 获取下一个元素
     *
     * @return 下一个元素
     */
    @Override
    public Object next() {
        Object o = concreteAggregate.arr[index];
        index++;
        return o;
    }

}

4、迭代器的优缺点
优点
它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足 “开闭原则” 的要求。
缺点
增加了类的个数，这在一定程度上增加了系统的复杂性。

本文由博客一文多发平台 OpenWrite 发布！