设计模式-迭代器模式（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;}@Overridepublic boolean hasNext() {return index < array.length;}@Overridepublic 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;}@Overridepublic boolean hasNext() {return index < list.size();}@Overridepublic 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()方法@Overridepublic Iterator<String> iterator() {return new MyIterator();}
}// 创建一个实现了Iterator接口的类
class MyIterator implements Iterator<String> {private int index;private String[] items;public MyIterator() {this.index = 0;}// 实现hasNext()方法@Overridepublic boolean hasNext() {return index < items.length;}// 实现next()方法@Overridepublic 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()方法@Overridepublic Iterator<Integer> iterator() {return new MyIterator();}
}// 创建一个实现Iterator接口的类
class MyIterator implements Iterator<Integer> {private int[] data;private int index;public MyIterator() {this.index = 0;}// 实现hasNext()方法@Overridepublic boolean hasNext() {return index < data.length;}// 实现next()方法@Overridepublic 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;@Overridepublic boolean hasNext() {return index < numbers.length;}@Overridepublic 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;}@Overridepublic boolean hasNext() {return index < items.length;}@Overridepublic 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());}}
}