Java迭代器模式的实现原理

Java迭代器模式的概念

在Java编程中，迭代器模式是一种行为型设计模式，它提供了一种顺序访问聚合对象中各个元素，而又不暴露该对象内部表示的方法。迭代器模式将遍历元素的责任从聚合对象中分离出来，放到迭代器对象中。这样一来，聚合对象只负责存储数据，而迭代器对象负责遍历数据，使得两者的职责更加单一和清晰。

从更直观的角度理解，假设我们有一个装满书籍的书架，书架就是聚合对象，里面存放了很多书（元素）。如果没有迭代器，要想一本本查看书架上的书，书架就需要提供非常复杂的方法来支持顺序访问。而有了迭代器模式，就如同给书架配了一个专门的“查书助手”，这个助手（迭代器）知道如何按照顺序一本本拿出书架上的书供我们查看，书架本身只需要知道怎么存放书就好。

Java迭代器模式的角色构成

迭代器接口（Iterator Interface）：定义了遍历元素所需的方法，如 hasNext() 判断是否还有下一个元素，next() 获取下一个元素，在Java中，java.util.Iterator 接口就是所有迭代器的标准接口。
具体迭代器类（Concrete Iterator）：实现了迭代器接口，负责管理遍历的当前位置等状态，并按照聚合对象的结构来具体实现元素的遍历逻辑。
聚合接口（Aggregate Interface）：定义了创建迭代器的方法，比如 iterator() 方法，该方法返回一个迭代器对象。
具体聚合类（Concrete Aggregate）：实现聚合接口，包含存储元素的数据结构，并实现创建迭代器的方法，返回一个具体的迭代器实例。

Java中迭代器模式的实现

定义聚合接口和具体聚合类 首先，我们定义一个聚合接口 MyAggregate，并创建一个实现该接口的具体聚合类 MyList。

// 聚合接口
interface MyAggregate<T> {
    MyIterator<T> iterator();
}

// 具体聚合类
class MyList<T> implements MyAggregate<T> {
    private T[] elements;
    private int size;

    public MyList(int capacity) {
        elements = (T[]) new Object[capacity];
        size = 0;
    }

    public void add(T element) {
        if (size < elements.length) {
            elements[size++] = element;
        }
    }

    @Override
    public MyIterator<T> iterator() {
        return new MyListIterator<>();
    }

    // 内部类实现具体迭代器
    private class MyListIterator<E> implements MyIterator<E> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }

        @Override
        public E next() {
            if (hasNext()) {
                return (E) elements[currentIndex++];
            }
            return null;
        }
    }
}

在上述代码中，MyAggregate 接口定义了 iterator() 方法用于创建迭代器。MyList 类实现了该接口，内部使用数组 elements 来存储元素，并通过 add 方法添加元素。MyList 类的 iterator 方法返回一个内部类 MyListIterator 的实例，这个内部类就是具体的迭代器。

定义迭代器接口和具体迭代器类

// 迭代器接口
interface MyIterator<T> {
    boolean hasNext();
    T next();
}

这里定义了 MyIterator 接口，包含 hasNext 和 next 方法。MyListIterator 类作为具体迭代器类，实现了该接口，通过 currentIndex 来跟踪当前遍历的位置，hasNext 方法判断是否还有下一个元素，next 方法返回当前位置的元素并将位置后移。

使用迭代器模式

public class IteratorPatternDemo {
    public static void main(String[] args) {
        MyList<String> myList = new MyList<>(5);
        myList.add("Apple");
        myList.add("Banana");
        myList.add("Cherry");

        MyIterator<String> iterator = myList.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

在 main 方法中，我们创建了 MyList 的实例并添加了一些元素，然后获取迭代器，通过 while 循环，利用迭代器的 hasNext 和 next 方法遍历并打印出所有元素。

Java集合框架中的迭代器模式

Java集合框架概述 Java集合框架（Java Collections Framework）是一个包含了多种数据结构和算法的框架，用于存储和操作数据集合。它主要包括 Collection 接口及其子接口（如 List、Set）和 Map 接口。在这个框架中，迭代器模式被广泛应用。
Collection 接口与迭代器 Collection 接口是Java集合框架中所有集合类的根接口之一，它定义了 iterator() 方法，用于返回一个 Iterator 实例。这体现了迭代器模式中的聚合接口角色。

public interface Collection<E> extends Iterable<E> {
    Iterator<E> iterator();
    // 其他方法省略
}

所有实现 Collection 接口的具体集合类，如 ArrayList、LinkedList、HashSet 等，都必须实现 iterator() 方法，返回具体的迭代器实例，这对应迭代器模式中的具体聚合类角色。

Iterator 接口 Java中的 java.util.Iterator 接口定义了标准的迭代器方法，包括 hasNext()、next() 和 remove()。

public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    // Java 8 新增的方法
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

具体集合类所返回的迭代器实现类实现了这些方法，以提供对集合元素的遍历功能，这对应迭代器模式中的具体迭代器类角色。

以 ArrayList 为例 ArrayList 是 List 接口的一个实现类，它使用数组来存储元素。ArrayList 的 iterator 方法返回一个 Itr 类的实例，Itr 类是 ArrayList 的内部类，实现了 Iterator 接口。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    // 内部类 Itr 实现 Iterator 接口
    private class Itr implements Iterator<E> {
        int cursor;       // 下一个要返回的元素的索引
        int lastRet = -1; // 上次返回的元素的索引
        int expectedModCount = modCount;

        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();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    @Override
    public Iterator<E> iterator() {
        return new Itr();
    }
    // 其他方法省略
}

在 Itr 类中，cursor 变量记录下一个要返回的元素的索引，lastRet 记录上次返回的元素的索引，expectedModCount 用于检测集合在迭代过程中是否被意外修改。hasNext 方法判断是否还有下一个元素，next 方法返回下一个元素并更新索引，remove 方法用于删除上次返回的元素。

迭代器模式在Java中的优势

分离职责 迭代器模式将聚合对象的遍历职责从聚合对象本身分离出来，聚合对象只负责数据的存储和管理，迭代器负责数据的遍历。这样使得代码的职责更加明确，每个类的功能更加单一，提高了代码的可维护性和可扩展性。例如，在 ArrayList 中，ArrayList 类专注于数组的管理和元素的添加、删除等操作，而 Itr 类专注于如何遍历数组中的元素。
统一遍历方式 Java集合框架通过迭代器模式为所有实现 Collection 接口的集合类提供了统一的遍历方式。无论集合类内部是使用数组、链表还是其他数据结构存储元素，都可以通过 Iterator 接口来进行遍历。这使得开发者在遍历不同类型的集合时可以使用相同的代码结构，提高了代码的通用性和可复用性。例如，遍历 ArrayList 和 LinkedList 都可以使用相同的迭代器代码：

List<String> arrayList = new ArrayList<>();
arrayList.add("A");
arrayList.add("B");
Iterator<String> arrayListIterator = arrayList.iterator();
while (arrayListIterator.hasNext()) {
    String element = arrayListIterator.next();
    System.out.println(element);
}

List<String> linkedList = new LinkedList<>();
linkedList.add("C");
linkedList.add("D");
Iterator<String> linkedListIterator = linkedList.iterator();
while (linkedListIterator.hasNext()) {
    String element = linkedListIterator.next();
    System.out.println(element);
}

支持多种遍历策略 通过创建不同的迭代器实现类，可以为同一个聚合对象提供多种遍历策略。例如，对于一个链表结构的聚合对象，可以创建一个正向遍历的迭代器，也可以创建一个反向遍历的迭代器。在Java中虽然标准的 Iterator 主要用于正向遍历，但一些集合类可能提供额外的迭代器实现来支持不同的遍历方式，如 ListIterator 接口，它继承自 Iterator 接口，提供了向前和向后遍历的方法，还可以在遍历过程中修改列表元素。

List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    System.out.println(listIterator.next());
}
while (listIterator.hasPrevious()) {
    System.out.println(listIterator.previous());
}

隐藏内部结构 迭代器模式允许聚合对象隐藏其内部的数据结构，外部代码只通过迭代器来访问聚合对象的元素，而不需要了解聚合对象内部是如何存储和组织这些元素的。这提高了聚合对象的封装性，保护了内部数据结构不被外部代码随意修改。例如，ArrayList 使用数组存储元素，但外部代码通过 Iterator 遍历 ArrayList 时，不需要知道它使用数组这一内部细节。

迭代器模式在实际应用中的场景

数据展示与处理 在图形用户界面（GUI）开发中，经常需要将数据集合（如数据库查询结果、配置文件中的数据等）展示在列表框、表格等组件中。迭代器模式可以方便地遍历这些数据集合，并将数据逐个显示在相应的组件上。同时，在对这些数据进行批量处理（如数据验证、数据转换等）时，也可以使用迭代器依次处理每个元素。例如，在一个学生管理系统中，从数据库查询出学生列表后，可以使用迭代器将学生信息逐个显示在JTable组件中，并且可以在迭代过程中对学生成绩进行合法性验证等操作。
遍历树形结构 在处理树形结构数据（如文件系统目录树、XML文档树等）时，迭代器模式非常有用。可以为树形结构定义一个迭代器，通过迭代器来遍历树中的节点。例如，在文件系统中，要遍历某个目录及其所有子目录下的所有文件，可以使用迭代器按照深度优先或广度优先的策略进行遍历。以下是一个简单的文件系统目录遍历示例：

import java.io.File;
import java.util.Iterator;
import java.util.Stack;

class DirectoryIterator implements Iterator<File> {
    private Stack<File> stack = new Stack<>();

    public DirectoryIterator(File root) {
        stack.push(root);
    }

    @Override
    public boolean hasNext() {
        return!stack.isEmpty();
    }

    @Override
    public File next() {
        File file = stack.pop();
        if (file.isDirectory()) {
            File[] children = file.listFiles();
            if (children != null) {
                for (int i = children.length - 1; i >= 0; i--) {
                    stack.push(children[i]);
                }
            }
        }
        return file;
    }
}

public class FileSystemTraversal {
    public static void main(String[] args) {
        File root = new File(".");
        DirectoryIterator iterator = new DirectoryIterator(root);
        while (iterator.hasNext()) {
            File file = iterator.next();
            System.out.println(file.getAbsolutePath());
        }
    }
}

在上述代码中，DirectoryIterator 类实现了对文件目录的迭代遍历，通过栈来实现深度优先遍历。

迭代器与设计模式结合 迭代器模式常常与其他设计模式结合使用。例如，在访问者模式中，迭代器可以用于遍历对象结构，使得访问者可以依次访问结构中的每个元素。假设我们有一个由不同类型图形（如圆形、矩形、三角形）组成的图形集合，使用迭代器遍历这个集合，然后通过访问者模式对每个图形进行不同的操作（如计算面积、绘制图形等）。

// 图形接口
interface Shape {
    void accept(ShapeVisitor visitor);
}

// 圆形
class Circle implements Shape {
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);
    }
}

// 矩形
class Rectangle implements Shape {
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);
    }
}

// 访问者接口
interface ShapeVisitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
}

// 图形集合类
class ShapeCollection {
    private Shape[] shapes;
    private int size;

    public ShapeCollection(int capacity) {
        shapes = new Shape[capacity];
        size = 0;
    }

    public void add(Shape shape) {
        if (size < shapes.length) {
            shapes[size++] = shape;
        }
    }

    public ShapeIterator iterator() {
        return new ShapeIterator();
    }

    private class ShapeIterator implements Iterator<Shape> {
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }

        @Override
        public Shape next() {
            if (hasNext()) {
                return shapes[currentIndex++];
            }
            return null;
        }
    }
}

// 具体访问者
class AreaCalculator implements ShapeVisitor {
    @Override
    public void visit(Circle circle) {
        // 计算圆形面积的逻辑
        System.out.println("Calculating area of circle");
    }

    @Override
    public void visit(Rectangle rectangle) {
        // 计算矩形面积的逻辑
        System.out.println("Calculating area of rectangle");
    }
}

public class VisitorPatternWithIterator {
    public static void main(String[] args) {
        ShapeCollection collection = new ShapeCollection(5);
        collection.add(new Circle());
        collection.add(new Rectangle());

        ShapeIterator iterator = collection.iterator();
        AreaCalculator calculator = new AreaCalculator();
        while (iterator.hasNext()) {
            Shape shape = iterator.next();
            shape.accept(calculator);
        }
    }
}

在这个示例中，ShapeCollection 类使用迭代器模式提供遍历功能，AreaCalculator 作为访问者，通过迭代器遍历 ShapeCollection 中的每个图形并执行相应的操作。

迭代器模式的注意事项

并发修改异常 在使用迭代器遍历集合时，如果在迭代过程中对集合进行结构性修改（如添加、删除元素），可能会抛出 ConcurrentModificationException 异常。这是因为迭代器在创建时记录了集合的结构状态（如 modCount），如果在迭代过程中集合结构发生变化，迭代器检测到状态不一致就会抛出异常。例如，在 ArrayList 的 Itr 类中，next 方法和 remove 方法都会检查 modCount 是否与 expectedModCount 一致，如果不一致则抛出异常。为了避免这种情况，可以使用迭代器的 remove 方法来删除元素，因为它会正确更新 modCount 和 expectedModCount。如果需要添加元素，可以使用 ListIterator 接口的 add 方法，它也能正确处理结构变化。
性能问题 虽然迭代器模式提供了统一和方便的遍历方式，但在某些情况下可能会存在性能问题。例如，对于大型集合，使用迭代器进行遍历可能会消耗较多的内存和时间。特别是在迭代器实现中使用了复杂的数据结构或算法时，性能问题可能更加明显。在这种情况下，可以考虑使用更高效的遍历方式，如索引访问（如果集合支持）或并行遍历（在Java 8及以后可以使用流来实现并行操作）。另外，如果迭代器在遍历过程中进行大量的计算或I/O操作，也可能导致性能瓶颈，需要优化这些操作的实现。
迭代器的生命周期 需要注意迭代器的生命周期，一旦迭代器创建并开始使用，它与聚合对象之间就存在一定的关联。如果在迭代过程中聚合对象被销毁或发生重大变化，可能会导致迭代器行为异常。例如，假设一个聚合对象是通过数据库查询结果构建的临时集合，在迭代过程中数据库连接关闭或数据被删除，那么迭代器可能无法正常工作。因此，在设计中要确保迭代器的使用范围与聚合对象的生命周期相匹配，避免出现悬空迭代器（dangling iterator）的情况。
自定义迭代器的设计 当自定义迭代器时，要确保其实现的正确性和健壮性。除了正确实现 hasNext、next 等基本方法外，还需要考虑一些边界情况，如集合为空时的处理、遍历到最后一个元素后的行为等。同时，自定义迭代器的性能也需要关注，尽量避免在迭代器实现中引入不必要的复杂性和性能开销。另外，如果自定义迭代器与其他设计模式结合使用，要确保它们之间的协同工作是正确和可靠的。

综上所述，Java迭代器模式是一种强大且常用的设计模式，它在Java集合框架以及各种实际应用场景中都发挥着重要作用。通过深入理解其实现原理、优势、应用场景和注意事项，开发者能够更加灵活和高效地使用迭代器模式来解决各种编程问题，提高代码的质量和可维护性。无论是处理简单的数据集合遍历，还是复杂的树形结构处理以及与其他设计模式的结合，迭代器模式都为我们提供了一种优雅而有效的解决方案。在实际编程中，合理运用迭代器模式，并注意其相关的要点，将有助于开发出更加健壮和高效的Java程序。