一、迭代器模式概述
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());
}
}
}