设计模式-迭代器模式（Iterator）

一、迭代器模式概述

1.1 什么是迭代器模式

迭代器模式是一种设计模式，它用于提供一种方法来访问一个容器对象中的各个元素，而又不暴露该对象的内部表示。

在迭代器模式中，我们定义一个抽象的迭代器类，它包含两个方法：一个是hasNext()方法，用于判断是否还有下一个元素；另一个是next()方法，用于获取下一个元素。然后，每个容器类都实现自己的迭代器类，以访问容器中的元素。

1.2 简单实现迭代器模式

首先，我们定义一个接口Iterator，它表示一个迭代器：

interface Iterator {
    boolean hasNext();
    Object next();
}

然后，我们可以实现一些具体的迭代器类，例如数组迭代器和列表迭代器：

class ArrayIterator implements Iterator {
    private final int[] array;
    private int index;

    public ArrayIterator(int[] array) {
        this.array = array;
        this.index = 0;
    }

    @Override
    public boolean hasNext() {
        return index < array.length;
    }

    @Override
    public Object next() {
        return array[index++];
    }
}

class ListIterator implements Iterator {
    private final List<Object> list;
    private int index;

    public ListIterator(List<Object> list) {
        this.list = list;
        this.index = 0;
    }

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

    @Override
    public Object next() {
        return list.get(index++);
    }
}

接下来，我们可以使用这些迭代器类来遍历容器中的元素：

int[] array = {1, 2, 3, 4, 5};
ArrayIterator arrayIterator = new ArrayIterator(array);
while (arrayIterator.hasNext()) {
    System.out.println(arrayIterator.next()); // 输出：1, 2, 3, 4, 5
}

List<Object> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");
ListIterator listIterator = new ListIterator(list);
while (listIterator.hasNext()) {
    System.out.println(listIterator.next()); // 输出：apple, banana, orange
}

1.3 使用迭代器模式的注意事项

• 1、容器对象需要实现Iterable接口，并实现iterator()方法，该方法返回一个迭代器对象。

• 2、迭代器对象需要实现Iterator接口，并实现hasNext()和next()方法。

• 3、在使用迭代器遍历容器中的元素时，需要先调用hasNext()方法判断是否还有下一个元素，如果有再调用next()方法获取下一个元素。

• 4、在遍历过程中，如果修改了容器中的元素，可能会导致迭代器失效或抛出异常。因此，在遍历过程中应该避免对容器进行修改操作。

• 5、如果需要在遍历过程中删除容器中的元素，可以使用迭代器的remove()方法。但是需要注意的是，在使用remove()方法后，迭代器将指向被删除元素的下一个元素，而不是当前元素。因此，在使用remove()方法后，需要再次调用next()方法才能获取正确的元素。

• 6、如果需要在遍历过程中添加元素到容器中，可以使用迭代器的add()方法。但是需要注意的是，在使用add()方法后，迭代器将指向新添加的元素，而不是当前元素。因此，在使用add()方法后，需要再次调用next()方法才能获取正确的元素。

二、迭代器模式的用途

• 1、支持以不同的方式遍历一个聚合对象：迭代器模式将聚合对象的遍历行为分离出来，提供了多种遍历方式。

• 2、简化了聚合类：通过引入迭代器，可以将遍历逻辑从聚合类中分离出来，使得聚合类的职责更加单一。

• 3、增加了代码的灵活性和可扩展性：由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无需修改原有代码。

• 4、让外部代码能够透明地访问集合内部的数据：迭代器负责集合对象的遍历，可以让外部的代码无需关心集合的内部表示，而直接访问其中的数据。

三、迭代器模式实现方式

3.1 使用Iterator接口实现迭代器模式

要使用Java中的Iterator接口实现迭代器模式，首先需要创建一个实现了Iterable接口的类要使用Java中的Iterator接口实现迭代器模式，首先需要创建一个实现了Iterable接口的类，然后在该类中实现iterator()方法。接下来，创建一个实现了Iterator接口的类，并在该类中实现hasNext()和next()方法。以下是一个简单的示例：

// 创建一个实现了Iterable接口的类
class MyIterable implements Iterable<String> {
    private String[] items;

    public MyIterable(String[] items) {
        this.items = items;
    }

    // 实现iterator()方法
    @Override
    public Iterator<String> iterator() {
        return new MyIterator();
    }
}

// 创建一个实现了Iterator接口的类
class MyIterator implements Iterator<String> {
    private int index;
    private String[] items;

    public MyIterator() {
        this.index = 0;
    }

    // 实现hasNext()方法
    @Override
    public boolean hasNext() {
        return index < items.length;
    }

    // 实现next()方法
    @Override
    public String next() {
        return items[index++];
    }
}

public class Main {
    public static void main(String[] args) {
        String[] items = {"A", "B", "C", "D"};
        MyIterable myIterable = new MyIterable(items);

        for (String item : myIterable) {
            System.out.println(item);
        }
    }
}

在这个示例中，我们创建了一个名为MyIterable的类，它实现了Iterable接口。我们还创建了一个名为MyIterator的类，它实现了Iterator接口。在主方法中，我们创建了一个MyIterable对象，并使用for-each循环遍历其元素。

3.2 使用Iterable接口和Iterator接口实现迭代器模式

要使用Java中的Iterable接口和Iterator接口实现迭代器模式，首先需要创建一个类实现Iterable接口，然后在该类中实现iterator()方法。接下来，创建一个实现Iterator接口的类，并在该类中实现hasNext()和next()方法。以下是一个简单的示例：

// 创建一个实现Iterable接口的类
class MyIterable implements Iterable<Integer> {
    private int[] data;

    public MyIterable(int[] data) {
        this.data = data;
    }

    // 实现iterator()方法
    @Override
    public Iterator<Integer> iterator() {
        return new MyIterator();
    }
}

// 创建一个实现Iterator接口的类
class MyIterator implements Iterator<Integer> {
    private int[] data;
    private int index;

    public MyIterator() {
        this.index = 0;
    }

    // 实现hasNext()方法
    @Override
    public boolean hasNext() {
        return index < data.length;
    }

    // 实现next()方法
    @Override
    public Integer next() {
        return data[index++];
    }
}

public class Main {
    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4, 5};
        MyIterable myIterable = new MyIterable(data);

        for (int num : myIterable) {
            System.out.println(num);
        }
    }
}

在这个示例中，我们创建了一个名为MyIterable的类，它实现了Iterable接口。我们还创建了一个名为MyIterator的类，它实现了Iterator接口。在主方法中，我们创建了一个MyIterable对象，并使用for-each循环遍历其元素。

3.3 使用匿名内部类实现迭代器模式

在Java中，可以使用匿名内部类实现迭代器模式。以下是一个简单的示例：

import java.util.Iterator;

public class AnonymousInnerClassIterator {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        // 使用匿名内部类实现迭代器模式
        Iterator<Integer> iterator = new Iterator<Integer>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < numbers.length;
            }

            @Override
            public Integer next() {
                return numbers[index++];
            }
        };

        // 遍历数组并打印元素
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

在这个示例中，我们创建了一个匿名内部类实现了Iterator接口，并重写了hasNext()和next()方法。然后，我们使用这个匿名内部类的实例来遍历一个整数数组。

3.4 使用Lambda表达式实现迭代器模式

在Java中，可以使用Lambda表达式实现迭代器模式。以下是一个简单的示例：

首先，创建一个接口Iterator，包含两个方法：hasNext()和next()。

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

然后，创建一个类MyIterator，实现Iterator接口。在这个类中，使用Lambda表达式定义hasNext()和next()方法。

import java.util.function.Supplier;

public class MyIterator<T> implements Iterator<T> {
    private T[] items;
    private int index = 0;

    public MyIterator(T[] items) {
        this.items = items;
    }

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

    @Override
    public T next() {
        return items[index++];
    }
}

最后，在主函数中使用MyIterator类。

public class Main {
    public static void main(String[] args) {
        Integer[] numbers = {1, 2, 3, 4, 5};
        MyIterator<Integer> iterator = new MyIterator<>(numbers);

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