设计模式之迭代器

迭代器模式是一种常见的设计模式，它可以帮助我们访问和遍历一个集合对象中的元素，而无需暴露其内部实现。在 Java 中，迭代器模式通常通过实现 Iterator 接口来实现。本篇博客将详细讲解迭代器模式的基本概念、使用方法和示例代码。

基本概念

迭代器模式是一种行为型设计模式，它将遍历集合对象中的元素与集合对象本身分离开来，从而使得集合对象可以独立于其遍历算法而变化。通常，迭代器模式包含如下角色：

• 迭代器（Iterator）：定义访问和遍历元素的接口，包括 hasNext() 方法、next() 方法和 remove() 方法等。
• 具体迭代器（ConcreteIterator）：实现迭代器接口，用于遍历集合对象中的元素。
• 集合（Collection）：定义创建迭代器对象的接口，并提供了访问和遍历元素的方法。
• 具体集合（ConcreteCollection）：实现集合接口，用于创建具体迭代器对象。

使用方法

在 Java 中，我们可以使用迭代器模式来访问和遍历集合对象中的元素，而无需了解其内部实现。具体步骤如下：

1. 定义迭代器接口 Iterator，包含 hasNext() 方法、next() 方法和 remove() 方法等。
2. 定义集合接口 Collection，包含创建迭代器对象的方法和访问和遍历元素的方法。
3. 实现具体迭代器类 ConcreteIterator，实现迭代器接口，用于遍历集合对象中的元素。
4. 实现具体集合类 ConcreteCollection，实现集合接口，用于创建具体迭代器对象和提供访问和遍历元素的方法。

示例代码

下面是一个使用迭代器模式的示例代码，其中我们使用迭代器模式来遍历一个数组中的元素：

import java.util.Iterator;

public interface MyCollection<T> {
    Iterator<T> createIterator();
}

public class MyArrayList<T> implements MyCollection<T> {
    private Object[] elements;
    private int size;

    public MyArrayList() {
        this.elements = new Object[10];
        this.size = 0;
    }

    public void add(T element) {
        if (this.size == this.elements.length) {
            Object[] newElements = new Object[this.elements.length * 2];
            System.arraycopy(this.elements, 0, newElements, 0, this.elements.length);
            this.elements = newElements;
        }
        this.elements[this.size++] = element;
    }

    public T get(int index) {
        if (index < 0 || index >= this.size) {
            throw new IndexOutOfBoundsException("Index out of bounds: " + index);
        }
        return (T) this.elements[index];
    }

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

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

public class MyArrayListIterator<T> implements Iterator<T> {
    private MyArrayList<T> list;
    private int cursor;

    public MyArrayListIterator(MyArrayList<T> list) {
        this.list = list;
        this.cursor = 0;
    }

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

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("No more elements.");
        }
        return this.list.get(this.cursor++);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Remove operation is not supported.");
    }
}

public class Client {
    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");

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

在上面的代码中，我们定义了一个接口 MyCollection，其中包含一个创建迭代器对象的方法 createIterator()。我们还实现了一个具体集合类 MyArrayList，其中包含一个数组和若干个方法用于添加、获取和计算元素个数。在 createIterator() 方法中，我们实现了创建迭代器对象的逻辑，返回了一个具体迭代器对象 MyArrayListIterator。

我们还实现了一个具体迭代器类 MyArrayListIterator，其中包含一个 MyArrayList 对象和一个游标变量 cursor。在 hasNext() 方法中，我们判断游标变量是否小于集合中元素的个数；在 next() 方法中，我们返回游标所指向的元素，并将游标加一；在 remove() 方法中，我们抛出一个 UnsupportedOperationException 异常，表示不支持删除操作。

最后，在客户端代码中，我们创建了一个 MyArrayList 对象，向其中添加了若干个元素，然后创建了一个迭代器对象，并使用 while 循环遍历了这个集合中的所有元素，并将其打印输出。

总结

迭代器模式是一种常见的设计模式，它可以帮助我们访问和遍历一个集合对象中的元素，而无需了解其内部实现。在 Java 中，迭代器模式通常通过实现 Iterator 接口来实现，其中包含 hasNext() 方法、next() 方法和 remove() 方法等。迭代器模式的主要优点是可以将遍历算法与集合对象分离，从而提高代码的灵活性和可维护性。