当前位置：首页 > article >正文

迭代器模式 (Iterator Pattern)

article 2024/11/29 20:30:09

文章目录

- - 迭代器模式 (Iterator Pattern)
  - 原理
  - 优点
  - 缺点
  - 示例代码
  - - 场景描述
    - 1. 定义迭代器接口
    - 2. 定义集合接口
    - 3. 实现具体集合类
    - 4. 客户端代码
    - 输出结果
  - UML 类图
  - 使用场景
  - 优化与扩展
  - 小结

迭代器模式 (Iterator Pattern)

迭代器模式是一种 行为型设计模式，用于顺序访问集合对象中的元素，而无需暴露集合的内部表示。它提供了一种统一的方式来遍历不同类型的集合。

原理

核心思想：
- 将集合的遍历逻辑封装在迭代器对象中，分离集合对象的存储和迭代行为。
适用场景：
- 需要访问集合对象中的内容，而不希望暴露其内部结构。
- 需要以不同方式遍历集合。
- 提供一个统一接口，支持多种类型集合的迭代。
参与角色：
- Iterator（迭代器接口）：
  - 定义访问和遍历元素的方法。
- ConcreteIterator（具体迭代器）：
  - 实现迭代器接口，负责具体的遍历行为。
- Aggregate（集合接口）：
  - 定义创建迭代器的接口。
- ConcreteAggregate（具体集合）：
  - 实现集合接口，并返回具体的迭代器。

优点

单一职责原则：
- 集合类负责存储数据，迭代器负责遍历，分离了职责。
开放/封闭原则：
- 可以新增不同的迭代方式，而无需修改集合类。
统一接口：
- 不同集合的遍历方式对外统一。

缺点

开销：
- 如果集合很大，创建多个迭代器对象可能会增加内存开销。
访问限制：
- 某些高级操作（如随机访问）可能不适用于简单迭代器。

示例代码

场景描述

设计一个自定义集合类 CustomCollection，并提供一个迭代器来遍历其中的元素。

1. 定义迭代器接口

// 迭代器接口
public interface Iterator<T> {
    boolean hasNext();  // 是否还有下一个元素
    T next();           // 获取下一个元素
}

2. 定义集合接口

// 集合接口
public interface Aggregate<T> {
    Iterator<T> createIterator();  // 创建迭代器
}

3. 实现具体集合类

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

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

    // 添加元素
    public void add(T item) {
        items.add(item);
    }

    // 获取元素
    public T get(int index) {
        return items.get(index);
    }

    // 获取集合大小
    public int size() {
        return items.size();
    }

    // 创建迭代器
    @Override
    public Iterator<T> createIterator() {
        return new CustomIterator();
    }

    // 具体迭代器类
    private class CustomIterator implements Iterator<T> {
        private int index = 0; // 当前索引

        @Override
        public boolean hasNext() {
            return index < items.size();
        }

        @Override
        public T next() {
            return items.get(index++);
        }
    }
}

4. 客户端代码

public class IteratorPatternExample {
    public static void main(String[] args) {
        // 创建集合
        CustomCollection<String> collection = new CustomCollection<>();
        collection.add("Element 1");
        collection.add("Element 2");
        collection.add("Element 3");

        // 获取迭代器
        Iterator<String> iterator = collection.createIterator();

        // 使用迭代器遍历集合
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出结果

Element 1
Element 2
Element 3

UML 类图

        +----------------+
        |   Aggregate    |<-----------------+
        +----------------+                  |
        | + createIterator(): Iterator<T>   |
        +----------------+                  |
                ^                           |
                |                           |
  +---------------------------+     +-------------------+
  |   CustomCollection<T>     |     |    Iterator<T>    |
  +---------------------------+     +-------------------+
  | - items : List<T>         |     | + hasNext(): bool |
  | + add(item): void         |     | + next(): T       |
  | + createIterator(): CustomIterator<T> |
  +---------------------------+     +-------------------+
                ^                           ^
                |                           |
  +---------------------------+     +-------------------+
  |   CustomIterator<T>       |     |       Client      |
  +---------------------------+     +-------------------+
  | - index : int             |     
  | + hasNext(): bool         |
  | + next(): T               |
  +---------------------------+