博主介绍： ✌博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家✌

Java知识图谱点击链接：体系化学习Java（Java面试专题）

💕💕 感兴趣的同学可以收藏关注下 ，不然下次找不到哟💕💕

1、什么是迭代器模式

迭代器模式是一种行为设计模式，它允许按照特定顺序访问聚合对象中的元素，而无需暴露其内部表示。迭代器模式提供了一种统一的方式来遍历不同类型的集合，而不需要了解其底层实现。

在迭代器模式中，聚合对象包含一个迭代器，该迭代器用于遍历聚合对象中的元素。迭代器提供了一组方法，如获取下一个元素、判断是否还有下一个元素等。通过使用迭代器，客户端代码可以独立于聚合对象的具体类型来遍历元素。

迭代器模式的优点包括简化聚合对象的接口、提供一种统一的遍历方式、支持多种遍历方式等。它可以使代码更加灵活和可扩展，同时也符合面向对象设计的原则。

总结来说，迭代器模式是一种用于遍历聚合对象的设计模式，它提供了一种统一的方式来访问聚合对象中的元素，从而提高了代码的灵活性和可扩展性。

2、迭代器模式的优缺点

迭代器模式的优点包括：

1. 简化聚合对象的接口：迭代器模式将遍历集合的责任封装在迭代器中，使得聚合对象不需要暴露其内部结构，从而简化了聚合对象的接口。

2. 统一的遍历方式：迭代器模式提供了一种统一的遍历方式，无论聚合对象的类型如何，都可以使用相同的迭代器接口进行遍历操作。

3. 支持多种遍历方式：迭代器模式可以定义多个不同的迭代器类，每个迭代器类可以以不同的方式遍历聚合对象，从而满足不同的遍历需求。

4. 提高代码灵活性和可扩展性：由于迭代器模式将遍历操作与聚合对象分离，使得可以独立地修改聚合对象或迭代器的实现，而不会相互影响，从而提高了代码的灵活性和可扩展性。

迭代器模式的缺点包括：

1. 增加了类的数量：引入迭代器模式会增加额外的迭代器类，可能会增加代码量和复杂度。

2. 遍历过程中的修改问题：如果在遍历过程中修改了聚合对象，可能会导致迭代器的状态和聚合对象的状态不一致，需要特别注意遍历过程中的修改操作。

综上所述，迭代器模式具有简化接口、统一遍历方式、支持多种遍历方式以及提高代码灵活性和可扩展性等优点，但也需要注意增加类的数量和遍历过程中的修改问题。

3、迭代器模式的应用场景

迭代器模式在以下情况下可以应用：

1. 需要遍历一个聚合对象的元素，但又不希望暴露其内部表示。迭代器模式可以提供一种统一的方式来遍历聚合对象，而不需要了解其具体实现。

2. 需要在不同的聚合对象上使用统一的遍历方式。迭代器模式可以定义一个通用的迭代器接口，使得可以在不同的聚合对象上使用相同的迭代器进行遍历操作。

3. 需要支持多种遍历方式。迭代器模式可以定义多个不同的迭代器类，每个迭代器类可以以不同的方式遍历聚合对象，从而满足不同的遍历需求。

4. 需要遍历的聚合对象可能有不同的底层实现。迭代器模式可以将遍历操作与具体的聚合对象实现分离，使得可以独立地修改聚合对象的实现，而不会影响遍历的代码。

5. 需要提供一种安全的遍历方式。迭代器模式可以在遍历过程中保护聚合对象，防止非法访问或修改。

总之，迭代器模式适用于需要遍历聚合对象的场景，同时希望将遍历操作与聚合对象的具体实现分离的情况。它可以提供一种统一的、灵活的遍历方式，同时支持多种遍历需求。

4、迭代器模式的结构

迭代器模式的结构包括以下几个角色：

1. 抽象迭代器（Iterator）：定义了访问和遍历聚合对象元素的接口，包括获取下一个元素、判断是否还有元素等方法。

2. 具体迭代器（ConcreteIterator）：实现了抽象迭代器接口，负责具体的遍历聚合对象的操作，记录当前遍历位置等。

3. 抽象聚合对象（Aggregate）：定义了创建迭代器对象的接口，可以是一个抽象类或接口，提供了获取迭代器的方法。

4. 具体聚合对象（ConcreteAggregate）：实现了抽象聚合对象的接口，创建具体的迭代器对象，实现了具体的聚合对象的操作。

5. 客户端（Client）：使用迭代器模式的代码，通过迭代器遍历聚合对象的元素。

迭代器模式的核心思想是将遍历操作封装在迭代器中，使得聚合对象的内部结构对外隐藏，客户端只需要通过迭代器访问聚合对象的元素，从而实现了聚合对象与遍历操作的分离。这样可以提供一种统一的、灵活的遍历方式，同时支持多种遍历需求。

5、迭代器模式的原理

迭代器模式的原理是通过将遍历操作封装在迭代器对象中，实现对聚合对象的遍历访问。具体来说，迭代器模式包括以下几个步骤：

1. 定义抽象迭代器接口（Iterator），其中包括一些用于遍历聚合对象的方法，如获取下一个元素、判断是否还有元素等。

2. 在具体迭代器类（ConcreteIterator）中实现抽象迭代器接口，具体实现遍历聚合对象的操作。具体迭代器类通常会持有一个对应的聚合对象，并记录当前遍历位置等状态信息。

3. 定义抽象聚合对象接口（Aggregate），其中包括一个用于创建迭代器对象的方法。抽象聚合对象可以是一个抽象类或接口，具体实现类需要实现该方法。

4. 在具体聚合对象类（ConcreteAggregate）中实现抽象聚合对象接口，创建具体的迭代器对象。具体聚合对象类通常会持有一个聚合对象的集合，并在创建迭代器时将自身作为参数传递给迭代器。

5. 在客户端代码中，通过抽象聚合对象接口获取迭代器对象，然后使用迭代器对象进行遍历操作。客户端代码不需要了解具体的聚合对象和迭代器实现，只需要通过迭代器接口进行遍历操作。

迭代器模式的核心思想是将遍历操作封装在迭代器对象中，使得聚合对象的内部结构对外隐藏，客户端只需要通过迭代器访问聚合对象的元素，从而实现了聚合对象与遍历操作的分离。这样可以提供一种统一的、灵活的遍历方式，同时支持多种遍历需求

6、迭代器模式的代码案例

定义抽象迭代器接口

package com.pany.camp.design.principle.iterator;

/**
 *
 * @description:  定义抽象迭代器接口
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 20:10
 */
public interface Iterator<T> {
   
   

    boolean hasNext();

    T next();
}

定义具体迭代器类

package com.pany.camp.design.principle.iterator;

import java.util.List;

/**
 *
 * @description:  定义具体迭代器类
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-06-28 20:11
 */
public class ConcreteIterator<T> implements Iterator<T> {
   
   

    private List<T> collection;

    private int index;

    public ConcreteIterator(List<T> collection) {
   
   
        this.collection = collection;
        this.index = 0;
    }

    public boolean hasNext() {
   
   
        return index < collection.size();
    }

    public T next() {
   
   
        if (hasNext()) {
   
   
            T item = collection.get(index);
            index++;
            return item;
        }
        return null;
    }
}

定义抽象聚合对象接口

package com.pany.camp.design.principle.iterator;

/**
 *
 * @description:   定义抽象聚合对象接口
 * @copyright: @Copyright (c) 2022
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0
 * @createTime: 2023-06-28 20:12
 */
public interface Aggregate<T> {
   
   

    Iterator<T> createIterator();
}

定义具体聚合对象类

package com.pany.camp.design.principle.iterator;

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

/**
 *
 * @description:  定义具体聚合对象类
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 20:13
 */
public class ConcreteAggregate<T> implements Aggregate<T> {
   
   

    private List<T> collection;

    public ConcreteAggregate() {
   
   
        this.collection = new ArrayList<>();
    }

    public void addItem(T item) {
   
   
        collection.add(item);
    }

    public Iterator<T> createIterator() {
   
   
        return new ConcreteIterator<>(collection);
    }
}

客户端：

package com.pany.camp.design.principle.iterator;

/**
 *
 * @description:  客户端代码
 * @copyright: @Copyright (c) 2022 
 * @company: Aiocloud
 * @author: pany
 * @version: 1.0.0 
 * @createTime: 2023-06-28 20:13
 */
public class Client {
   
   

    public static void main(String[] args) {
   
   
        ConcreteAggregate<Integer> aggregate = new ConcreteAggregate<>();
        aggregate.addItem(1);
        aggregate.addItem(2);
        aggregate.addItem(3);

        Iterator<Integer> iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
   
   
            Integer item = iterator.next();
            System.out.println(item);
        }
    }
}

我们定义了抽象迭代器接口（Iterator）和具体迭代器类（ConcreteIterator），以及抽象聚合对象接口（Aggregate）和具体聚合对象类（ConcreteAggregate）。客户端代码通过创建具体聚合对象并获取迭代器，然后使用迭代器遍历聚合对象中的元素。

输出如下：

1
2
3

Process finished with exit code 0

💕💕 本文由激流原创，原创不易，感谢支持
💕💕喜欢的话记得点赞收藏啊