Java 迭代器（Iterator）详解

一、迭代器的基本概念

迭代器（Iterator）是 Java 集合框架中的一个核心接口，位于 java.util 包下。它定义了一种标准的元素访问机制，为各种集合类型（如 List、Set、Queue 等）提供了一种统一的遍历方式。

详细说明

基本功能：
- hasNext()：检查集合中是否还有未遍历的元素
- next()：返回集合中的下一个元素
- remove()：从集合中移除当前元素（可选操作）
设计目的：
- 提供统一的遍历接口，屏蔽不同集合的内部实现差异
- 支持安全的并发修改（fail-fast 机制）
- 实现"惰性求值"，只在需要时才获取元素

典型使用场景：

java 复制代码

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String element = it.next();
    System.out.println(element);
}

与其他遍历方式的对比：
- 比传统的 for 循环更安全（避免下标越界）
- 比增强 for 循环更灵活（支持 remove 操作）
- 适用于所有实现 Iterable 接口的集合类
注意事项：
- 不能保证遍历顺序（具体取决于集合实现）
- 大部分情况下不支持并发修改
- 使用后通常会成为"失效"状态
扩展机制：
- ListIterator：针对 List 的增强迭代器，支持双向遍历和修改操作
- Spliterator：Java 8 引入的并行遍历迭代器

迭代器模式是设计模式中行为型模式的一种典型实现，体现了"单一职责"和"开闭原则"的设计思想。

二、迭代器的获取方式

在 Java 集合框架中，所有实现了 java.util.Collection 接口的集合类都提供了 iterator() 方法。这个方法返回一个实现了 java.util.Iterator 接口的迭代器对象，用于遍历集合中的元素。这种设计模式遵循了迭代器模式（Iterator Pattern），将集合的遍历操作与集合的具体实现分离，提供了一种统一的方式来访问各种不同类型的集合。

Iterator 接口定义了三个核心方法：

hasNext()：判断集合中是否还有下一个元素
next()：返回集合中的下一个元素
remove()：从集合中移除当前元素（可选操作）

下面是一个更详细的获取和使用迭代器的示例代码，展示了完整的迭代过程：

java 复制代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {
    public static void main(String[] args) {
        // 创建一个ArrayList集合（ArrayList是Collection接口的实现类）
        Collection<String> collection = new ArrayList<>();
        
        // 向集合中添加元素
        collection.add("张三");
        collection.add("李四");
        collection.add("王五");
        collection.add("赵六");
        
        // 获取该集合的迭代器对象
        Iterator<String> iterator = collection.iterator();
        
        // 使用while循环遍历集合元素
        System.out.println("集合中的元素有：");
        while(iterator.hasNext()) {
            // 获取当前元素
            String element = iterator.next();
            System.out.println(element);
            
            // 示例：移除特定元素
            if(element.equals("李四")) {
                iterator.remove();  // 安全地移除当前元素
            }
        }
        
        // 查看移除后的集合
        System.out.println("\n移除'李四'后的集合：");
        iterator = collection.iterator();  // 重新获取迭代器
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

在实际开发中，迭代器常用于以下场景：

需要边遍历边删除集合元素时（使用for-each循环会抛出ConcurrentModificationException）
需要访问某些特殊集合（如ConcurrentHashMap的视图集合）时
需要统一处理不同类型集合的遍历逻辑时

需要注意的是，迭代器是单向的，一旦遍历完成就不能重置，如果需要重新遍历，必须重新获取迭代器对象。此外，多个迭代器可以同时操作同一个集合，它们之间互不影响。

三、迭代器的基础操作

1. hasNext() 方法

hasNext()方法用于判断集合中是否还有下一个元素可供访问，其返回值为boolean类型。该方法不会移动迭代器的指针位置，只是检查当前位置之后是否还有元素存在。

返回true的情况：当集合中还有未被遍历的元素时
返回false的情况：当迭代器已经到达集合末尾时
典型使用场景：作为while循环的条件，实现安全遍历

java 复制代码

// 示例：检查集合是否为空
List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
if(!it.hasNext()) {
    System.out.println("集合为空");
}

2. next() 方法

next()方法用于获取集合中的下一个元素。该方法会执行两个操作：

将迭代器的指针向后移动一位
返回当前指针所指向的元素

注意事项：

必须先用hasNext()检查，否则当集合中没有更多元素时会抛出NoSuchElementException
每次调用都会移动指针位置
返回的是Object类型，通常需要强制类型转换

java 复制代码

// 示例：安全使用next()
List<Integer> numbers = Arrays.asList(1, 2, 3);
Iterator<Integer> iterator = numbers.iterator();
while(iterator.hasNext()) {
    Integer num = iterator.next();  // 自动拆箱
    System.out.println(num * 2);  // 输出2,4,6
}

3. remove() 方法

remove()方法用于删除迭代器当前所指向的元素，即上一次调用next()方法返回的元素。

方法约束：

必须先调用next()获取元素后才能调用remove()
每次next()后只能调用一次remove()
不能独立调用remove()（即不能连续调用两次remove()）
会直接修改底层集合的结构

使用场景：

安全地删除集合元素
在遍历过程中动态修改集合

java 复制代码

// 示例：删除特定元素
List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
Iterator<String> it = names.iterator();
while(it.hasNext()) {
    String name = it.next();
    if(name.startsWith("A")) {
        it.remove();  // 安全删除以A开头的元素
    }
}

完整示例解析

下面是更详细的示例代码，展示了迭代器的完整使用流程：

java 复制代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class IteratorOperationDemo {

    public static void main(String[] args) {
        // 创建并初始化集合
        Collection<String> collection = new ArrayList<>();
        collection.add("张三");
        collection.add("李四");
        collection.add("王五");
        collection.add("赵六");
        
        // 获取迭代器实例
        Iterator<String> iterator = collection.iterator();
        
        // 安全遍历集合
        try {
            while (iterator.hasNext()) {
                String name = iterator.next();
                System.out.println("当前元素: " + name);
                
                // 条件删除
                if ("李四".equals(name)) {
                    iterator.remove();
                    System.out.println("已删除元素: 李四");
                }
            }
        } catch (NoSuchElementException e) {
            System.err.println("错误: 尝试访问不存在的元素");
        } catch (IllegalStateException e) {
            System.err.println("错误: remove()调用不当");
        }
        
        // 输出修改后的集合
        System.out.println("\n删除后的集合内容：");
        iterator = collection.iterator();  // 重新获取迭代器
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        // 验证集合大小
        System.out.println("\n最终集合大小: " + collection.size());
    }
}

输出结果分析：

复制代码

当前元素: 张三
当前元素: 李四
已删除元素: 李四
当前元素: 王五
当前元素: 赵六

删除后的集合内容：
张三
王五
赵六

最终集合大小: 3

最佳实践建议

使用增强for循环替代简单迭代：Java 5+可以使用增强for循环简化遍历
java 复制代码
```
for(String name : collection) {
    System.out.println(name);
}
```
并发修改问题 ：不要在迭代过程中直接通过集合方法修改集合结构（如add/remove），这会导致ConcurrentModificationException
多线程环境 ：在并发环境下，应考虑使用ConcurrentHashMap或CopyOnWriteArrayList等线程安全集合
资源管理：对于大型集合，迭代完成后可以显式地将迭代器置为null以帮助垃圾回收
性能考虑：对于ArrayList，使用索引的for循环通常比迭代器更快；但对于LinkedList，迭代器性能更好

四、迭代器的注意事项

在使用迭代器的过程中，有一些注意事项需要我们特别关注，否则可能会导致程序出现异常或不符合预期的结果。这些注意事项在实际开发中尤为重要，特别是在处理大数据集合或多线程环境下。

1.并发修改异常（ConcurrentModificationException）

当我们使用迭代器遍历集合时，如果在迭代过程中通过集合本身的方法（而不是迭代器的remove()方法）修改了集合的结构（如添加、删除元素），则会抛出ConcurrentModificationException异常。这个异常是Java集合框架设计的fail-fast机制的体现。

具体来说，迭代器在创建时会记录集合的modCount（修改次数），每次对集合进行结构性修改（如add、remove等操作）时，modCount都会递增。在迭代过程中，迭代器会检查当前modCount是否与创建时记录的expectedModCount一致，如果不一致，就会抛出该异常。

下面是一个会抛出ConcurrentModificationException异常的典型示例代码：

java 复制代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class ConcurrentModificationDemo {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("张三");
        collection.add("李四");
        collection.add("王五");

        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println(name);
            
            // 通过集合的add方法添加元素，会导致ConcurrentModificationException异常
            if ("李四".equals(name)) {
                collection.add("赵六");  // 这里会抛出异常
            }
        }
    }
}

运行上述代码，程序会在遍历到"李四"并尝试添加"赵六"时抛出ConcurrentModificationException异常。这种情况常见于以下场景：

在foreach循环中尝试修改集合
在多线程环境下一个线程迭代而另一个线程修改集合

为了避免出现这种异常，在迭代过程中如果需要修改集合的结构，应该使用迭代器提供的remove()方法：

java 复制代码

// 正确的修改方式
iterator.remove();  // 使用迭代器的remove方法

2.迭代器的单向性

Java中的迭代器是单向的，即只能从集合的开头向结尾遍历，不能反向遍历。这种设计主要是为了保持接口的简洁性和通用性。如果需要进行反向遍历，可以使用ListIterator（仅List接口的实现类支持），ListIterator继承了Iterator接口，并增加了反向遍历的相关方法，如hasPrevious()和previous()等。

ListIterator的主要特点包括：

支持双向遍历
允许在迭代过程中修改集合
可以获取当前元素的位置
可以在迭代过程中添加元素

下面是一个使用ListIterator进行反向遍历的完整示例代码：

java 复制代码

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        // 获取ListIterator
        ListIterator<String> listIterator = list.listIterator();
        
        // 先正向遍历到末尾
        System.out.println("正向遍历结果：");
        while (listIterator.hasNext()) {
            String name = listIterator.next();
            System.out.println(name);
        }

        // 反向遍历
        System.out.println("\n反向遍历结果：");
        while (listIterator.hasPrevious()) {
            String name = listIterator.previous();
            System.out.println(name);
        }
        
        // 在迭代过程中添加元素
        while (listIterator.hasNext()) {
            String name = listIterator.next();
            if ("李四".equals(name)) {
                listIterator.add("赵六");  // 在"李四"后面添加新元素
            }
        }
        
        System.out.println("\n修改后的列表：" + list);
    }
}

运行上述代码，输出结果为：

复制代码

正向遍历结果：
张三
李四
王五

反向遍历结果：
王五
李四
张三

修改后的列表：[张三, 李四, 赵六, 王五]

3.迭代器的失效

当集合的结构发生改变时（如使用集合的add()、remove()等方法），之前获取的迭代器可能会失效，继续使用该迭代器可能会出现不可预期的结果或抛出异常。这种情况在以下场景中特别常见：

在多线程环境中共享集合
在长时间运行的迭代过程中
在嵌套迭代时

因此，当集合的结构发生改变后，最佳实践是重新获取迭代器。例如：

java 复制代码

List<String> list = new ArrayList<>();
// ...添加元素...
Iterator<String> iter1 = list.iterator();

// 修改集合结构
list.add("新元素");

// 旧的迭代器可能失效，应该重新获取
Iterator<String> iter2 = list.iterator();  // 获取新的迭代器

4.对于不同集合的迭代器实现

不同的集合类对迭代器接口的实现可能有所不同，因此在使用迭代器遍历不同的集合时，其性能和行为可能会存在显著差异。

以下是一些常见集合类的迭代器特点比较：

集合类型	迭代器特点	适用场景
ArrayList	基于数组实现，next()方法效率高(O(1))，但插入删除操作会导致数组复制	随机访问频繁，修改操作少
LinkedList	基于链表实现，next()需要移动指针(O(n))，但插入删除效率高(O(1))	频繁插入删除操作
HashSet	基于哈希表实现，迭代顺序不确定	快速查找，不关心顺序
TreeSet	基于红黑树实现，迭代顺序是有序的	需要有序遍历
ConcurrentHashMap	弱一致性的迭代器，线程安全	多线程环境

选择集合类型时的建议：

如果需要频繁随机访问，选择ArrayList
如果需要频繁插入删除，选择LinkedList
多线程环境下考虑并发集合类
大数据量时考虑迭代器的性能差异

例如，在遍历LinkedList时，使用普通for循环的性能会很差：

java 复制代码

// 性能差的方式（LinkedList）
for (int i = 0; i < linkedList.size(); i++) {
    String s = linkedList.get(i);  // 每次get(i)都需要从头遍历
}

// 推荐的方式（使用迭代器）
Iterator<String> iter = linkedList.iterator();
while (iter.hasNext()) {
    String s = iter.next();  // 只需移动指针
}

理解这些差异有助于我们在实际开发中选择合适的集合类型和遍历方式，从而提高程序性能。