迭代器模式是一种行为型设计模式，用于提供一种顺序访问容器对象中各个元素的方法，同时不暴露容器内部结构。通过迭代器模式，我们可以在不关心容器内部实现的情况下，访问容器中的每个元素，从而简化了容器的遍历操作。迭代器模式广泛应用于各种集合类的实现中，如列表、树、图等，使得这些数据结构的遍历操作更加简洁和高效。
定义
迭代器模式（Iterator Pattern）的定义是：提供一种顺序访问一个聚合对象（容器）中各个元素的方法，而又不暴露其内部的表示。这意味着客户端代码可以使用迭代器对象来遍历聚合对象中的元素，而无需了解其内部实现细节。
使用场景
迭代器模式适用于以下场景：
- 透明地遍历容器元素：当需要透明地遍历一个容器中的元素，而不暴露其内部结构时，可以使用迭代器模式。
- 多种遍历方式：当希望有多种遍历方式，或者需要以不同的方式遍历同一个容器时，迭代器模式也很有用。
- 简化遍历操作：当需要简化复杂数据结构的遍历操作时，迭代器模式可以将遍历逻辑封装在迭代器中，提供统一的访问接口。
主要角色
迭代器模式主要包括以下角色：
- 迭代器（Iterator）：定义了访问和遍历元素的接口。
- 具体的迭代器（ConcreteIterator）：实现迭代器接口，提供具体的遍历逻辑。
- 聚合（Aggregate）：定义创建迭代器对象的接口。
- 具体的聚合（ConcreteAggregate）：实现了聚合接口，返回具体的迭代器对象。
类图
迭代器模式的类图
ArrayList继承体系的类图
核心思想
迭代器模式的核心思想是将容器对象的遍历行为抽象成一个单独的迭代器对象，使得可以通过迭代器对象逐个访问容器中的元素，而不需要了解容器内部的实现细节。这样可以将遍历算法与容器对象解耦，提高了系统的灵活性和可维护性。
优点
- 分离了聚合对象的遍历行为：迭代器模式将遍历算法封装在迭代器对象中，使得可以独立地改变和扩展遍历方式，而不需要修改聚合对象的代码。
- 简化了聚合对象的接口：迭代器模式可以隐藏聚合对象的内部结构，只需要暴露一个简单的迭代器接口，使得聚合对象更加简洁和易于使用。
- 支持多种遍历方式：迭代器模式可以为同一个聚合对象提供多个不同的迭代器，每个迭代器都可以实现不同的遍历方式，满足不同场景的需求。
缺点
- 增加了系统复杂度：引入迭代器对象会增加系统的类和对象数量，可能会增加系统的复杂度。
- 遍历过程中的并发修改问题：在使用迭代器遍历过程中，如果容器对象发生了结构性修改（如增删元素），可能会导致迭代器失效或出现异常，需要额外处理并发修改问题。
示例代码
Iterator 接口
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
具体的迭代器（ConcreteIterator）
private class Itr implements Iterator<E> {
int cursor; // 下一个要返回的元素的索引
int lastRet = -1; // 上一个返回的元素的索引; 如果没有返回元素则为-1
int expectedModCount = modCount; // 结构修改次数
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
聚合类（Aggregate）
public interface Aggregate<T> {
Iterator<T> iterator();
}
具体的聚合类（ConcreteAggregate）
public class ArrayList<E> implements Aggregate<E> {
// 省略其他代码
public Iterator<E> iterator() {
return new Itr();
}
// 省略其他代码
}
实际应用场景
在实际工作中，迭代器模式经常用于处理集合类（如列表、树等）的遍历问题。例如，在开发一个文件系统管理系统时，可以使用迭代器模式来遍历文件夹中的所有文件和子文件夹，而不需要暴露文件系统的内部结构。这样可以使得代码更加模块化和可维护，同时提高了系统的灵活性和可扩展性。
另一个常见的应用场景是图形用户界面（GUI）开发中组件的遍历。在复杂的GUI系统中，界面组件通常组织成树形结构，如Swing和JavaFX中的组件树。通过使用迭代器模式，可以方便地遍历和操作这些组件，而无需直接操作底层数据结构。
详细代码示例
为了更好地理解迭代器模式，我们可以参考一个更详细的代码示例，这里我们实现一个简单的列表类及其迭代器。
自定义列表类
首先，我们定义一个简单的列表类 MyList，它包含基本的添加元素和获取元素的方法。
public class MyList<E> {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_CAPACITY = 10;
public MyList() {
elements = new Object[DEFAULT_CAPACITY];
}
public void add(E element) {
if (size == elements.length) {
ensureCapacity();
}
elements[size++] = element;
}
public E get(int index) {
if (index >= size || index < 0) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
return (E) elements[index];
}
public int size() {
return size;
}
private void ensureCapacity() {
int newSize = elements.length * 2;
elements = Arrays.copyOf(elements, newSize);
}
public Iterator<E> iterator() {
return new MyListIterator();
}
private class MyListIterator implements Iterator<E> {
private int currentIndex = 0;
@Override
public boolean hasNext() {
return currentIndex < size;
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return (E) elements[currentIndex++];
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
}
使用自定义列表类
接下来，我们将展示如何使用 MyList 类及其迭代器来遍历元素。
public class IteratorPatternDemo {
public static void main(String[] args) {
MyList<String> myList = new MyList<>();
myList.add("Element 1");
myList.add("Element 2");
myList.add("Element 3");
Iterator<String> iterator = myList.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
}
}
输出结果：
Element 1
Element 2
Element 3
通过上述代码示例，我们可以清楚地看到如何使用迭代器模式来遍历自定义的列表类 MyList。通过实现 Iterator 接口并在 MyList 类中提供 iterator 方法，我们能够以一种统一的方式遍历列表中的元素，而不需要关心列表的内部实现细节。
进阶应用：支持多种遍历方式
迭代器模式不仅可以实现简单的遍历，还可以支持多种遍历方式。接下来我们通过一个进阶示例展示如何为同一个容器对象提供多种迭代器。
自定义双向链表类
我们将定义一个双向链表类 DoublyLinkedList，它支持前向和后向遍历。
public class DoublyLinkedList<E> {
private Node<E> head;
private Node<E> tail;
private int size = 0;
private static class Node<E> {
E element;
Node<E> next;
Node<E> prev;
Node(E element, Node<E> next, Node<E> prev) {
this.element = element;
this.next = next;
this.prev = prev;
}
}
public void add(E element) {
Node<E> newNode = new Node<>(element, null, tail);
if (tail != null) {
tail.next = newNode;
}
tail = newNode;
if (head == null) {
head = newNode;
}
size++;
}
public int size() {
return size;
}
public Iterator<E> forwardIterator() {
return new ForwardIterator();
}
public Iterator<E> backwardIterator() {
return new BackwardIterator();
}
private class ForwardIterator implements Iterator<E> {
private Node<E> current = head;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
E element = current.element;
current = current.next;
return element;
}
}
private class BackwardIterator implements Iterator<E> {
private Node<E> current = tail;
@Override
public boolean hasNext() {
return current != null;
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
E element = current.element;
current = current.prev;
return element;
}
}
}
使用双向链表类
接下来，我们展示如何使用 DoublyLinkedList 类及其多种迭代器来遍历元素。
public class IteratorPatternDemo {
public static void main(String[] args) {
DoublyLinkedList<String> list = new DoublyLinkedList<>();
list.add("Element 1");
list.add("Element 2");
list.add("Element 3");
System.out.println("Forward iteration:");
Iterator<String> forwardIterator = list.forwardIterator();
while (forwardIterator.hasNext()) {
String element = forwardIterator.next();
System.out.println(element);
}
System.out.println("\nBackward iteration:");
Iterator<String> backwardIterator = list.backwardIterator();
while (backwardIterator.hasNext()) {
String element = backwardIterator.next();
System.out.println(element);
}
}
}
输出结果：
Forward iteration:
Element 1
Element 2
Element 3
Backward iteration:
Element 3
Element 2
Element 1
通过上述代码示例，我们可以看到如何为 DoublyLinkedList 类提供多种遍历方式。通过定义 ForwardIterator 和 BackwardIterator 两种不同的迭代器，我们能够分别实现前向遍历和后向遍历。
实际工作中的应用
在实际工作中，迭代器模式经常用于处理复杂数据结构的遍历。例如：
- 文件系统遍历：在开发文件系统管理系统时，可以使用迭代器模式来遍历文件夹中的所有文件和子文件夹，而不需要暴露文件系统的内部结构。这样可以使得代码更加模块化和可维护，同时提高了系统的灵活性和可扩展性。
- 数据库结果集遍历：在数据库访问中，可以使用迭代器模式来遍历查询结果集。通过定义一个结果集迭代器，可以方便地处理数据库查询结果，而不需要关心底层数据访问的实现细节。
- 图形用户界面（GUI）组件遍历：在复杂的GUI系统中，界面组件通常组织成树形结构，如Swing和JavaFX中的组件树。通过使用迭代器模式，可以方便地遍历和操作这些组件，而无需直接操作底层数据结构。
总结
迭代器模式是一种非常有用的设计模式，它将遍历操作封装在迭代器对象中，使得客户端代码可以透明地访问容器中的元素，而不需要关心容器的内部实现细节。这样可以提高代码的可读性和可维护性，并且使得系统更加灵活和可扩展。
通过实现和使用迭代器模式，我们能够简化复杂数据结构的遍历操作，支持多种遍历方式，提高系统的灵活性和扩展性。在实际工作中，迭代器模式广泛应用于集合类的实现、文件系统遍历、数据库结果集遍历和GUI组件遍历等场景，显著提升了代码的模块化和可维护性。
扫一扫
357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
