【设计模式深度剖析】【5】【行为型】【迭代器模式】

👈️上一篇:策略模式
设计模式-专栏👈️

文章目录

迭代器模式
定义
迭代器模式的角色
- [1. Iterator（迭代器）](#1. Iterator（迭代器）)
- [2. ConcreteIterator（具体迭代器）](#2. ConcreteIterator（具体迭代器）)
- [3. Aggregate（聚合）](#3. Aggregate（聚合）)
- [4. ConcreteAggregate（具体聚合）](#4. ConcreteAggregate（具体聚合）)
- 类图
- 代码示例
迭代器模式的应用

迭代器模式

迭代器模式（Iterator Pattern）的关键思想：

将对列表的访问和遍历 从列表对象 中分离出来并放入一个迭代器 （iterator）对象中。

迭代器模式就像是一个"导游"，它能够引导我们安全、有序地遍历集合中的"景点"，无需我们亲自去探索整个集合的内部结构。

定义

英文原话

The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

直译

迭代器模式提供了一种顺序访问聚合对象中的元素的方法，而又不需暴露该对象的内部表示。

如何理解呢？

想象一下，我们有一个装满各种水果的篮子（集合），而我们想逐一品尝每种水果（遍历元素）。但我们不希望直接把手伸进篮子里去取水果（暴露内部表示），因为这样可能会把篮子弄乱。

这时，我们可以使用一个迭代器（比如一个长柄勺），它可以帮助我们按顺序从篮子里取出水果，而不需要我们直接接触到篮子内部。每次我们用勺子取出一颗水果后，它就会指向下一个水果的位置。这样，我们就可以轻松品尝完所有的水果，同时保持篮子的整洁和有序。

迭代器模式就是这样一种工具，它让我们能够方便地遍历集合中的元素，同时保持集合的完整性和封装性。在软件开发中，这种模式的应用场景非常广泛，特别是在处理复杂数据结构时，它能够大大提高代码的可读性和可维护性。

迭代器模式的角色

迭代器模式中的角色通常包括：

1. Iterator（迭代器）

定义了访问和遍历元素的接口。

2. ConcreteIterator（具体迭代器）

实现了迭代器接口，并跟踪遍历中的当前位置。

3. Aggregate（聚合）

定义了创建迭代器对象的接口。

4. ConcreteAggregate（具体聚合）

实现了聚合接口，并返回具体迭代器的实例。

类图

代码示例

java 复制代码

// 迭代器接口
interface Iterator {
    boolean hasNext();

    Object next();
}

// 具体迭代器  
class ConcreteIterator implements Iterator {
    private List<Integer> list;
    private int currentIndex = 0;

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

    @Override
    public boolean hasNext() {
        return currentIndex < list.size();
    }

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

// 聚合接口  
interface Aggregate {
    Iterator createIterator();
}

// 具体聚合  
class ConcreteAggregate implements Aggregate {
    private List<Integer> list = new ArrayList<>();

    public void add(Integer item) {
        list.add(item);
    }

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

// 客户端代码  
public class Client {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();

        // 添加一些元素到聚合对象中  
        for (int i = 0; i < 10; i++) {
            aggregate.add(i);
        }

        // 获取迭代器并遍历聚合对象  
        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next()+"\t");
        }
    }
}

/* Output:
0	1	2	3	4	5	6	7	8	9	
*///~

在上面的示例中，我们定义了迭代器接口Iterator，它有两个方法：hasNext()用于检查是否还有下一个元素，next()用于获取下一个元素。然后，我们创建了ConcreteIterator类来实现这个接口，并跟踪当前遍历的位置。

Aggregate接口定义了创建迭代器的方法，而ConcreteAggregate类实现了这个接口，并提供了一个List来存储元素，并且有一个方法用于返回ConcreteIterator的实例。

在客户端代码中，我们创建了一个ConcreteAggregate对象，并向其中添加了一些元素。然后，我们获取了一个迭代器，并使用它来遍历聚合对象中的所有元素。

迭代器模式的应用

迭代器模式在软件开发中广泛应用于需要遍历集合对象（如列表、集合、映射等）的场景。它提供了一种统一的方式来访问集合中的元素，而不需要关心集合的内部结构和实现细节。通过迭代器，我们可以顺序地访问集合中的每一个元素，同时保持集合的封装性。

迭代器模式的优点

简化代码：通过将遍历操作封装在迭代器中，可以避免在客户端代码中编写重复的遍历逻辑，从而简化代码结构。
支持多种遍历方式：迭代器模式允许我们在不修改原有代码的情况下，通过实现不同的迭代器类来支持多种遍历方式。
隐藏内部实现 ：迭代器模式将集合的内部实现与遍历操作分离 ，客户端 代码只需要通过迭代器接口 来访问集合中的元素，无需关心集合的具体实现。
扩展性好：如果需要添加新的集合类，只需要实现对应的迭代器类即可，无需修改原有代码。

迭代器模式的缺点

类的个数成对增加：由于迭代器模式将存储数据和遍历数据的职责分离，每增加一个集合类，就需要增加一个对应的迭代器类，这在一定程度上增加了系统的复杂性。
可能增加系统开销：由于需要创建迭代器对象来遍历集合，这可能会增加一些额外的系统开销。

迭代器模式的使用场景

内容保密：当需要访问集合对象的内容，但又不希望暴露其内部表示时，可以使用迭代器模式。这样可以保持集合的封装性，同时提供一种统一的访问方式。
统一接口：当需要为不同的集合结构提供统一的遍历接口时，可以使用迭代器模式。通过实现统一的迭代器接口，可以使得客户端代码更加简洁、可复用。

👈️上一篇:策略模式
设计模式-专栏👈️