迭代器模式：遍历容器内元素-51CTO.COM

迭代器模式是一种行为型设计模式，它允许你在不暴露集合内部结构的情况下遍历集合中的所有元素。这种模式提供了一种统一的方式来访问不同类型的集合，使得客户端代码可以遍历集合，而不需要关心集合的具体实现细节。

什么是迭代器模式？

迭代器模式是一种行为型设计模式，它用于提供一种方法来访问聚合对象中的元素，而不需要暴露该对象的内部结构。迭代器模式将遍历集合的责任委托给一个独立的迭代器对象，这样可以在不影响集合的情况下添加新的遍历方式。

迭代器模式的关键角色包括：

抽象迭代器（Iterator）：定义了遍历集合元素的接口，包括 next()、hasNext() 等方法。
具体迭代器（ConcreteIterator）：实现了迭代器接口，负责管理遍历集合的状态。
抽象聚合类（Aggregate）：定义了创建迭代器对象的接口，通常包括一个 createIterator() 方法。
具体聚合类（ConcreteAggregate）：实现了创建迭代器对象的方法，它包含了要被迭代的集合。

为什么需要迭代器模式？

在软件开发中，我们经常需要遍历集合中的元素，如数组、列表、树等。传统的遍历方式是使用索引、循环等，但这样的方式存在一些问题：

暴露集合的内部结构：传统方式需要暴露集合的内部实现细节，使得客户端代码依赖于具体的集合类型。
遍历方式固定：传统方式只支持一种遍历方式，如果需要不同的遍历方式，就需要修改客户端代码。

迭代器模式解决了这些问题，它将遍历集合的责任委托给一个独立的迭代器对象，客户端代码可以通过不同的迭代器实现来遍历集合，而不需要了解集合的具体实现。

常见的设计原则与概念

在理解迭代器模式之前，让我们回顾一下一些常见的设计原则和概念：

单一职责原则（Single Responsibility Principle，SRP）：一个类应该只有一个引起变化的原因。这意味着一个类应该只有一个职责。迭代器模式符合这一原则，因为它将遍历集合的职责与集合本身的职责分离。
开闭原则（Open-Closed Principle，OCP）：软件实体应该对扩展开放，对修改关闭。迭代器模式允许在不修改集合类的情况下添加新的遍历方式，符合开闭原则。

常用的设计模式有哪些？

迭代器模式是一种常用的设计模式，但还有许多其他常用的设计模式，例如：

工厂方法模式：用于创建对象，将对象的实例化过程延迟到子类。
单例模式：确保一个类只有一个实例，并提供全局访问点。
观察者模式：定义对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会得到通知。
策略模式：定义一系列算法，将它们封装起来，并使它们可以互相替换。
装饰器模式：动态地给对象添加额外的职责，是继承的替代方案之一。

常见的使用场景

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

当需要遍历一个集合对象，但不希望暴露其内部结构时，可以使用迭代器模式。
当希望提供多种不同的遍历方式，而不想修改集合类的代码时，可以使用迭代器模式。
当希望将遍历算法与集合类分离，使得它们可以独立变化时，可以使用迭代器模式。

实际示例

让我们通过一个示例来演示迭代器模式的用法。假设我们有一个简单的集合类 MyList，它包含了一组整数。我们希望能够使用迭代器来遍历这个集合。

首先，我们定义抽象迭代器接口 Iterator：

// 抽象迭代器接口
public interface Iterator {
    boolean hasNext();
    int next();
}

然后，我们实现具体的迭代器类 MyListIterator：

// 具体迭代器类
public class MyListIterator implements Iterator {
    private MyList myList;
    private int index = 0;

    public MyListIterator(MyList myList) {
        this.myList = myList;
    }

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

    @Override
    public int next() {
        if (hasNext()) {
            int value = myList.get(index);
            index++;
            return value;
        } else {
            throw new NoSuchElementException();
        }
    }
}

接下来，我们定义抽象聚合类 MyList 和具体聚合类 ConcreteMyList：

// 抽象聚合类
public interface MyList {
    Iterator createIterator();
    int size();
    int get(int index);
}

// 具体聚合类
public class ConcreteMyList implements MyList {
    private List<Integer> list = new ArrayList<>();

    public void add(int value) {
        list.add(value);
    }

    @Override
    public Iterator createIterator() {
        return new MyListIterator(this);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public int get(int index) {
        return list.get(index);
    }
}

最后，我们可以使用迭代器来遍历 MyList 集合：

public class Main {
    public static void main(String[] args) {
        ConcreteMyList myList = new ConcreteMyList();
        myList.add(1);
        myList.add(2);
        myList.add(3);

        Iterator iterator = myList.createIterator();
        while (iterator.hasNext()) {
            int value = iterator.next();
            System.out.println(value);
        }
    }
}

这段代码演示了如何使用迭代器模式来遍历集合，而不需要关心集合的具体实现。

总结

迭代器模式是一种行为型设计模式，它允许你在不暴露集合内部结构的情况下遍历集合中的元素。这种模式提供了一种统一的方式来访问不同类型的集合，使得客户端代码可以遍历集合，而不需要关心集合的具体实现细节。它符合单一职责原则和开闭原则，常用于需要遍历集合的场景。