设计模式之迭代器模式

迭代器模式详解

迭代器模式是一种行为设计模式,提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露其内部表示。迭代器模式将遍历元素的责任交给迭代器,而不是聚合对象,从而简化了聚合对象的接口和实现。

1. 模式结构

迭代器模式包含以下主要角色:

  • Iterator(迭代器): 定义访问和遍历元素的接口。

  • ConcreteIterator(具体迭代器): 实现迭代器接口,负责实现具体的遍历算法。

  • Aggregate(聚合): 定义创建相应迭代器对象的接口。

  • ConcreteAggregate(具体聚合): 实现创建相应迭代器对象的方法,返回具体迭代器的实例。

2. 优缺点比较

优点 缺点
支持以不同方式遍历一个聚合对象 聚合对象的类型和具体迭代器类之间耦合度较高
简化了聚合类 具体迭代器类的增加和修改可能对聚合类产生影响
封装了遍历元素的细节

3. 使用场景

迭代器模式通常在以下情况下使用:

  • 访问一个聚合对象的内容而无需暴露其内部表示。
  • 支持对聚合对象的多种遍历。
  • 提供一个统一的接口,用于遍历不同类型的聚合对象。

4. 示例代码

// 1. Iterator 迭代器
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

// 2. ConcreteIterator 具体迭代器
public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> list;
    private int index = 0;

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

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

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

// 3. Aggregate 聚合
public interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 4. ConcreteAggregate 具体聚合
public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> list = new ArrayList<>();

    public void add(T element) {
        list.add(element);
    }

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

// 5. Client 客户端
public class Client {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.add("Item 1");
        aggregate.add("Item 2");
        aggregate.add("Item 3");

        Iterator<String> iterator = aggregate.createIterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

以上示例中,ConcreteIterator 实现了 Iterator 接口,负责遍历具体聚合对象中的元素。ConcreteAggregate 实现了 Aggregate 接口,提供创建迭代器的方法。客户端通过具体聚合对象创建迭代器,并使用迭代器遍历元素。

你可能感兴趣的:(设计模式,设计模式,迭代器模式)