23种设计模式——迭代器模式 (Iterator Pattern）详解

✅作者简介：大家好，我是 Meteors., 向往着更加简洁高效的代码写法与编程方式，持续分享Java技术内容。

🍎个人主页：Meteors.的博客
💞当前专栏：设计模式
✨特色专栏：知识分享
🥭本文内容：23种设计模式------迭代器模式 (Iterator Pattern）
📚 ** ps ** ：阅读文章如果有问题或者疑惑，欢迎在评论区提问或指出

[一. 背景](#一. 背景)

[二. 简介](#二. 简介)

[三. 主要角色](#三. 主要角色)

[四. 适用场景](#四. 适用场景)

[五. 代码示例](#五. 代码示例)

[六. 优缺点](#六. 优缺点)

[七. 优化方式](#七. 优化方式)

[八. 总结](#八. 总结)

一. 背景

很多语言都有使用迭代器遍历列表的方式，迭代器模式其实就是这些实现的设计模式描述。***我们通过创建迭代器，在不知道元素内部结构的情况下对元素列表进行遍历。***下面将会详细的介绍这种设计模式。

二. 简介

Iterator 模式是一种行为型 设计模式，它提***供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。***这种模式可以把游走（traversal）的行为与聚合对象的结构分离，使得我们可以在不知道底层数据结构的情况下遍历其中的元素。

三. 主要角色

Iterator（迭代器接口）： 定义访问和遍历元素的接口，通常包括 hasNext()、next() 等方法。
ConcreteIterator（具体迭代器）： 实现 Iterator 接口，对该聚合对象进行遍历时跟踪当前位置。
Aggregate（聚合接口）： 定义创建相应迭代器对象的接口。
***ConcreteAggregate（具体聚合类）：***实现聚合接口，返回一个具体迭代器实例

四. 适用场景

访问一个聚合对象的内容而无需暴露其内部表示

支持对聚合对象的多种遍历方式

为遍历不同的聚合结构提供一个统一的接口

五. 代码示例

下面是一个简单的 Java 实现示例：

java 复制代码

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

// Iterator 接口
interface Iterator<T> {
    boolean hasNext();
    T next();
}

// Aggregate 接口
interface Aggregate<T> {
    Iterator<T> createIterator();
}

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

    public void add(T item) {
        items.add(item);
    }

    public void remove(T item) {
        items.remove(item);
    }

    public int size() {
        return items.size();
    }

    public T get(int index) {
        return items.get(index);
    }

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }
}

// 具体迭代器
class ConcreteIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;
    private int position = 0;

    public ConcreteIterator(ConcreteAggregate<T> aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public boolean hasNext() {
        return position < aggregate.size();
    }

    @Override
    public T next() {
        if (hasNext()) {
            return aggregate.get(position++);
        }
        return null;
    }
}

// 使用示例
public class IteratorDemo {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.add("第一个");
        aggregate.add("第二个");
        aggregate.add("第三个");

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

六. 优缺点

优点

简化了遍历 复杂数据结构的代码

同一个聚合对象可以有多个不同的迭代器

更容易增加新的聚合类和迭代器类

遍历算法可以独立于聚合结构变化

缺点

对于简单的集合或数组，可能会增加不必要的复杂性

增加了额外的类（迭代器类）

七. 优化方式

使用 Java 内置集合框架： 实际开发中，Java 提供了丰富的集合框架（如 List、Set、Map），它们都实现了自己的迭代器。我们可以直接使用这些内置的迭代器，而不需要自己实现。

java 复制代码

   import java.util.*;

   public class BuiltInIteratorDemo {
       public static void main(String[] args) {
           List<String> list = Arrays.asList("第一个", "第二个", "第三个");
           
           // 使用增强for循环（内部使用Iterator）
           for (String item : list) {
               System.out.println(item);
           }
           
           // 显式使用Iterator
           Iterator<String> iterator = list.iterator();
           while (iterator.hasNext()) {
               System.out.println(iterator.next());
           }
       }
   }

支持反向遍历： 可以扩展迭代器功能，使其支持双向遍历。

java 复制代码

   interface BidirectionalIterator<T> extends Iterator<T> {
       boolean hasPrevious();
       T previous();
   }

   class BidirectionalIteratorImpl<T> implements BidirectionalIterator<T> {
       private List<T> list;
       private int position;

       public BidirectionalIteratorImpl(List<T> list) {
           this.list = list;
           this.position = 0;
       }

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

       @Override
       public T next() {
           return list.get(position++);
       }

       @Override
       public boolean hasPrevious() {
           return position > 0;
       }

       @Override
       public T previous() {
           return list.get(--position);
       }
   }

***使用泛型增强类型安全：***上面的例子已经使用了泛型来保证类型安全，这是现代 Java 编程的重要实践。
***支持并发安全：***在多线程环境中，可以实现线程安全的迭代器或者使用 CopyOnWriteArrayList 等并发集合类。

使用函数式编程特性： Java 8 引入了 Stream API，提供了更强大的数据处理能力：

java 复制代码

   import java.util.*;
   import java.util.stream.*;

   public class StreamExample {
       public static void main(String[] args) {
           List<String> list = Arrays.asList("第一个", "第二个", "第三个");
           
           // 使用Stream API进行过滤和遍历
           list.stream()
               .filter(s -> s.contains("一"))
               .forEach(System.out::println);
       }
   }

八. 总结

在实际项目开发中，我们经常使用 Java 集合框架提供的迭代器，比如 ListIterator、Iterator 等，很少需要从头开始实现自己的迭代器模式。但理解这个模式有助于更好地使用现有的集合类以及解决特定的遍历问题。

最后，

其它设计模式会陆续更新，希望文章对你有所帮助！