迭代器模式

行为型模式

访问次数: 10

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

视频教程

类图

classDiagram
    class Iterator {
        <<interface>>
        +hasNext() boolean
        +next() Object
    }
    class ConcreteIterator {
        -aggregate: ConcreteAggregate
        -current: int
        +hasNext() boolean
        +next() Object
    }
    class Aggregate {
        <<interface>>
        +createIterator() Iterator
    }
    class ConcreteAggregate {
        -items: List~Object~
        +createIterator() Iterator
        +addItem(item: Object)
        +getItem(index: int) Object
        +getCount() int
    }
    Iterator <|-- ConcreteIterator
    Aggregate <|-- ConcreteAggregate
    ConcreteIterator --> ConcreteAggregate

源代码示例

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

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

// 具体聚合类
class ConcreteAggregate implements Aggregate {
    private List<Object> items = new ArrayList<>();
    
    public void addItem(Object item) {
        items.add(item);
    }
    
    public Object getItem(int index) {
        return items.get(index);
    }
    
    public int getCount() {
        return items.size();
    }
    
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
}

// 具体迭代器
class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int current = 0;
    
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }
    
    @Override
    public boolean hasNext() {
        return current < aggregate.getCount();
    }
    
    @Override
    public Object next() {
        if (hasNext()) {
            return aggregate.getItem(current++);
        }
        return null;
    }
}

# Python代码待添加

应用场景

当需要遍历聚合对象中的元素，且不希望暴露聚合对象的内部结构时。应用场景包括： 1）遍历集合中的元素，提供统一的遍历接口，隐藏底层数据结构 2）遍历树形结构中的节点，支持深度优先、广度优先等不同遍历方式 3）数据库查询结果遍历，将复杂的数据库操作封装成简单的迭代器接口 4）文件系统遍历，遍历目录和文件，支持递归和非递归遍历 5）XML/JSON文档遍历，遍历文档中的元素和属性 6）图形数据结构遍历，遍历图中的节点和边，支持不同的遍历算法

精选场景详解 —— 集合遍历：不暴露内部结构的统一迭代

问题背景

业务既用数组列表，又用链表、哈希表。若让调用方直接操作底层结构，会泄露封装，且遍历写法无法统一。

模式如何解决

选用迭代器模式：Aggregate 提供 createIterator()；Iterator 提供 hasNext/next。客户端只依赖迭代器接口遍历元素。好处： 1）隐藏 List/Tree/Graph 等内部表示； 2）支持多种遍历策略（如树的前序/后序可对应不同迭代器）； 3）符合单一职责：集合管存储，迭代器管游标。 Java 的 Iterator、C# 的 IEnumerator、foreach 语法都是该模式的语言级体现。

场景模型（角色映射）

将模式中的抽象角色映射到该业务领域的具体类：

classDiagram
    class Iterator {
        <<interface>>
        +hasNext() bool
        +next() Object
    }
    class ListIterator {
        -list: ArrayListAggregate
        -index: int
        +hasNext() bool
        +next() Object
    }
    class Aggregate {
        <<interface>>
        +createIterator() Iterator
    }
    class ArrayListAggregate {
        -items: Object[]
        +createIterator() Iterator
        +add(item: Object)
    }
    class ReportService {
        +printAll(agg: Aggregate)
    }
    Iterator <|.. ListIterator
    Aggregate <|.. ArrayListAggregate
    ArrayListAggregate --> ListIterator : creates
    ListIterator --> ArrayListAggregate
    ReportService --> Aggregate
    ReportService --> Iterator

返回首页开始练习