设计模式详解（十七）——迭代子模式

迭代子模式简介

迭代子模式定义
迭代子模式，也称为迭代器模式，是一种对象行为模式。它的定义是：提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。在迭代子模式中，迭代子是一个对象，它知道如何遍历集合，并且跟踪它当前在集合中的位置。迭代子提供了一种统一的方式来访问集合中的元素，无论集合的具体类型如何。迭代子模式的核心思想是将遍历集合的行为从集合本身中分离出来，这样集合就可以专注于自己的数据结构，而遍历集合的逻辑可以被封装在迭代子中。
迭代子模式在实际开发中经常用于处理集合类的数据，例如数组、列表、树等。它提供了一种灵活的方式来遍历集合中的元素，同时也使得代码更易于维护和扩展。通过将遍历集合的逻辑抽象出来，迭代子模式使得集合和遍历逻辑可以相互独立地变化，从而提高了代码的灵活性和可维护性。

迭代子模式包含以下角色：

1. 抽象迭代子（Iterator）：这是一个抽象角色，它定义了遍历元素所需的接口。迭代器的主要职责是提供一种方法来访问聚合对象中的元素，同时隐藏了聚合对象的内部表示。迭代器通常包含诸如获取下一个元素、判断是否还有更多元素等操作。
2. 具体迭代子（ConcreteIterator）：这个角色实现了迭代器接口，负责具体的遍历逻辑。它通常维护一个指向当前元素的游标，并在遍历过程中更新该游标的位置。具体迭代器需要了解聚合对象的内部结构，以便正确遍历其元素。
3. 聚合对象（Aggregate）：这也是一个抽象角色，它定义了创建迭代器对象的接口。聚合对象通常包含一组元素，并提供一个方法来获取一个迭代器对象，以便外部可以遍历这些元素。聚合对象不需要暴露其内部表示，只需提供获取迭代器的接口即可。
4. 具体聚合对象（ConcreteAggregate）：这个角色实现了聚合接口，负责创建具体的迭代器对象。具体聚合通常包含一组具体的元素，并实现了获取迭代器的方法，该方法返回一个与具体聚合对象相匹配的迭代器实例。

迭代子模式优缺点：
优点：

1. 多态迭代：它为不同的聚合结构提供了一致的遍历接口，使得一个迭代接口可以访问不同的聚集对象。
2. 简化聚集对象接口：通过将遍历逻辑封装在迭代器中，聚合对象的接口可以更加简洁和专一。聚合对象只需要提供一个创建迭代器的方法，而无需暴露其内部结构和遍历逻辑。
3. 元素迭代功能多样化：每个聚集对象都可以提供一个或多个不同的迭代器，这使得同种元素聚合结构可以有不同的迭代行为。
4. 提高代码的可读性和可维护性：使用迭代子模式可以使代码更加清晰和易于理解。遍历逻辑被封装在迭代器中，使得聚合对象的代码更加专注于其数据结构和核心功能。同时，由于迭代器的独立性，修改遍历逻辑时不会影响到聚合对象的代码，提高了代码的可维护性。
5. 支持多种遍历方式：迭代子模式允许在不修改聚合对象的前提下增加新的遍历方式。通过实现不同的迭代器，可以方便地支持正序、逆序、过滤等多种遍历需求。

缺点：

1. 实现复杂性：对于简单的遍历，如数组或有序列表，使用迭代子模式可能会增加实现的复杂性。所以对于小型项目或简单的数据结构，使用迭代子模式可能过于复杂和繁琐。
2. 类的数量增加：每次新增一个集合类，都需要增加相应的迭代器类，这可能会导致类的个数成对增加，增加了系统的复杂性，增加代码的复杂性和管理成本。
3. 性能开销：在某些情况下，使用迭代子模式可能会引入一些性能开销。由于每次遍历都需要创建新的迭代器对象，这可能会增加内存消耗和对象创建/销毁的开销。然而，这种开销通常是可以接受的，尤其是在需要灵活遍历聚合对象的情况下。

使用场景

1. 访问聚合对象内容而不暴露内部表示：当需要访问一个聚合对象的内容，但不希望直接暴露其内部数据结构时，可以使用迭代子模式。通过迭代器，可以在不了解聚合对象内部实现细节的情况下，遍历并访问其元素。
2. 为聚合对象提供多种遍历方式：当需要为聚合对象提供不同的遍历方式时，如正向遍历、逆向遍历、跳跃遍历等，迭代子模式非常适用。通过实现不同的迭代器，可以轻松支持多种遍历需求。
3. 统一遍历不同聚合结构：当需要为不同类型的聚合结构提供一个统一的遍历接口时，迭代子模式可以发挥作用。无论是列表、栈、树还是图等数据结构，都可以通过迭代器进行统一的遍历操作，从而简化代码和提高可维护性。
4. 隐藏集合对象的内部结构：当需要隐藏集合对象的内部结构，只提供统一的遍历接口时，迭代子模式非常有用。这样，外部代码可以透明地访问集合内部的数据，而无需了解集合的具体实现细节。

以下举一个迭代子模式的例子：
下面通过一个简单的例子来演示。

创建抽象聚合对象（Aggregate）

/**
 * 抽象聚合对象:定义了创建迭代器对象的接口
 */
public interface Aggregate {

    public void add(String str);

    public void remove(String str);

    public Iterator getIterator();
}
1
2
3
4
5
6
7
8
9
10
11

创建具体聚合对象（ConcreteAggregate）

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

/**
 * 具体聚合对象:实现了聚合接口，负责创建具体的迭代器对象
 */
public class ConcreteAggregate implements Aggregate {
    private List<String> list=new ArrayList<String>();
    public void add(String str)
    {
        list.add(str);
    }
    public void remove(String str)
    {
        list.remove(str);
    }
    public Iterator getIterator()
    {
        return(new ConcreteIterator(list));
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

创建抽象迭代子（Iterator）

/**
 * 抽象迭代子:抽象角色，它定义了遍历元素所需的接口
 */
public interface Iterator {
    String first();
    String next();
    boolean hasNext();
}
1
2
3
4
5
6
7
8

创建具体迭代子（ConcreteIterator）

import java.util.List;

/**
 * 具体迭代子:实现了迭代器接口，负责具体的遍历逻辑
 */
public class ConcreteIterator implements Iterator {
    private List<String> list;
    private int index;

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

    // 判断列表对象中是否还有参数
    public boolean hasNext()
    {
        if(index < list.size()-1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // 获取对象列表中第一个参数
    public String first()
    {
        index = 0;
        String str = list.get(index);;
        return str;
    }

    // 获取对象列表中下一个参数
    public String next()
    {
        String str = null;
        if(this.hasNext())
        {
            str=list.get(++index);
        }
        return str;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

创建客户端（Client）

public class Client {
    public static void main(String[] args) {
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("篮球");
        aggregate.add("足球");
        aggregate.add("羽毛球");
        aggregate.add("网球");
        System.out.println("添加后的聚合对象内容有：");

        Iterator iterator = aggregate.getIterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.println(str);
        }

        System.out.println("===================");
        String str = iterator.first();
        System.out.println("聚合对象里第一个内容是：" + str);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出结果如下所示：

添加后的聚合对象内容有：
足球
羽毛球
网球
===================
聚合对象里第一个内容是：篮球
1
2
3
4
5
6

在上述例子中，我们定义了一个迭代子模式，包括抽象聚合对象、具体聚合对象、抽象迭代子和具体迭代子。Aggregate类中定义了添加元素、移除元素和获取迭代器对象的接口。在这个例子中，它包含一个添加字符串的add方法，一个移除字符串的remove方法，以及一个返回迭代器对象的getIterator方法。ConcreteAggregate 类实现了 Aggregate 接口，并使用一个 ArrayList 来存储元素。Iterator类中定义了迭代器的行为，定义了遍历元素所需的接口，包括first（获取第一个元素）、next（获取下一个元素）和hasNext（判断是否还有更多元素）方法。ConcreteIterator 类实现了 Iterator 接口，并提供了具体的遍历逻辑。客户端代码 (Client 类) 则是创建了一个 ConcreteAggregate对象，添加了一些元素，并通过迭代器遍历这些元素。

总而言之：
迭代子模式是一种行为设计模式，通过将遍历集合对象的行为封装在迭代子对象中，实现了遍历与集合对象的分离。它包括抽象迭代子、具体迭代子、聚合对象和具体聚合对象等角色。优点包括提高代码灵活性、模块化和隐藏集合对象内部结构；缺点是增加了代码复杂度和可能降低性能。适用于需要统一遍历接口、隐藏集合对象细节、提供多种遍历方式等场景。迭代子模式能够使代码更易维护、灵活，并提供一种统一的遍历方式，是一种常用的设计模式。
总之，迭代子模式通过将遍历集合的行为从集合对象中分离出来，实现了更好的封装和更灵活的设计。

以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git