Java中如何使用Iterator遍历集合

Iterator是遍历集合并安全移除元素的关键工具，通过hasNext()和next()方法遍历，用remove()避免ConcurrentModificationException；增强for循环简洁但无法安全删除元素；Java 8的Stream API适合数据处理与转换，而Iterator在需修改集合时仍不可替代。

在Java中，

Iterator

Iterator

解决方案

要使用

Iterator

Iterator

hasNext()

next()

remove()

下面是一个具体的例子：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorExample {
    public static void main(String[] args) {
        List fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");
        fruits.add("Grape");
        fruits.add("Banana"); // 再次添加一个香蕉

        System.out.println("原始列表: " + fruits);

        // 获取迭代器
        Iterator iterator = fruits.iterator();

        // 遍历并移除所有 "Banana"
        System.out.println("开始遍历并移除 'Banana'...");
        while (iterator.hasNext()) {
            String fruit = iterator.next(); // 获取当前元素
            System.out.println("正在处理: " + fruit);
            if ("Banana".equals(fruit)) {
                iterator.remove(); // 使用迭代器安全移除元素
                System.out.println("已移除 'Banana'");
            }
        }

        System.out.println("移除 'Banana' 后的列表: " + fruits);

        // 再次遍历，这次只是打印
        System.out.println("\n再次遍历剩余元素:");
        Iterator secondIterator = fruits.iterator();
        while (secondIterator.hasNext()) {
            System.out.println(secondIterator.next());
        }
    }
}

这段代码展示了

Iterator

fruits

fruits.remove(fruit)

ConcurrentModificationException

iterator.remove()

Iterator

立即学习“Java免费学习笔记（深入）”；

Iterator

与增强for循环有什么区别？我该如何选择？

这是个很常见的问题，也常常让人纠结。简单来说，增强for循环（

for-each

Iterator

Iterable

增强for循环的语法简洁优雅，非常适合只进行读取操作的遍历。比如，你只是想打印集合中的所有元素，或者对每个元素执行一些不涉及修改集合结构的操作，那么增强for循环无疑是首选，它代码量少，可读性高。

然而，如果你在遍历过程中需要从集合中移除元素，那么增强for循环就会让你头疼了。在增强for循环内部，如果你尝试通过集合自身的

remove()

ConcurrentModificationException

而

Iterator

remove()

iterator.remove()

ConcurrentModificationException

如何选择？

我的经验是，如果我只是想简单地遍历集合，不涉及任何修改操作，我会毫不犹豫地选择增强for循环，因为它更简洁。但只要我想到需要在遍历时移除元素，我的脑子里就会立刻浮现

Iterator

hasNext()

next()

Iterator

使用

Iterator

时常见的陷阱和最佳实践是什么？

即使

Iterator

Getimg.ai

getimg.ai是一套神奇的ai工具。生成大规模的原始图像

下载

常见陷阱：

1. ConcurrentModificationException

   的困扰： 这绝对是初学者最常遇到的问题。如果你在通过

   Iterator

   遍历一个集合的同时，又通过集合自身的

   add()

   或

   remove()

   方法（而不是

   iterator.remove()

   ）去修改这个集合，那么恭喜你，

   ConcurrentModificationException

   就会像不速之客一样跳出来。Java的集合（尤其是

   java.util

   包下的非同步集合）通常是“fail-fast”的，这意味着它们会尽快检测到这种并发修改并抛出异常，而不是让程序在不确定的状态下继续运行。

2. next()

   之前不检查

   hasNext()

   ： 有些时候，代码会忘记在调用

   iterator.next()

   之前，先用

   iterator.hasNext()

   检查一下集合是否还有下一个元素。如果集合已经遍历完，或者本来就是空的，直接调用

   next()

   就会抛出

   NoSuchElementException

   。这通常发生在循环条件设置不当或逻辑判断失误时。
3. 多次调用

   remove()

   ：

   iterator.remove()

   方法在每次调用

   next()

   之后，只能被调用一次。如果你在一次

   next()

   调用之后，又尝试多次调用

   remove()

   ，那么你会得到一个

   IllegalStateException

   。

   remove()

   总是移除最近一次

   next()

   返回的元素。

最佳实践：

1. 始终使用

   iterator.remove()

   进行移除操作： 这条是黄金法则。当你需要在遍历过程中修改集合时，这是唯一安全且推荐的方式。
2. 明确何时需要修改集合： 如果你的需求是遍历后才进行修改（例如，先收集所有需要移除的元素，然后在一个单独的循环中移除它们），那么你甚至可以避免

   Iterator

   的

   remove()

   方法，这有时能让代码逻辑更清晰。但这取决于具体场景。
3. 理解“fail-fast”机制： 知道

   ConcurrentModificationException

   的存在是为了帮助你发现并发修改问题，而不是一个bug。在单线程环境中，这意味着你不能在迭代时用集合自身的方法修改它。在多线程环境中，你需要考虑使用

   java.util.concurrent

   包下的线程安全集合（如

   CopyOnWriteArrayList

   ），或者进行外部同步。
4. 清晰的循环结构： 确保你的

   while (iterator.hasNext())

   循环条件是正确的，并且

   next()

   和

   remove()

   的调用顺序和次数是符合规范的。一个标准的模式是

   while (iterator.hasNext()) { element = iterator.next(); if (condition) { iterator.remove(); } }

   。

除了

Iterator

，Java 8 还有哪些更现代的集合遍历方式？

Java 8 引入的 Stream API 彻底改变了我们处理集合的方式，它提供了一种更声明式、函数式编程风格的集合处理方法。虽然 Stream API 并不是

Iterator

1. forEach()

   方法： 这是最直接的替代之一，用于对集合中的每个元素执行一个操作。它接受一个

   Consumer

   函数式接口作为参数。

   List names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
   names.forEach(name -> System.out.println("Hello, " + name));

   这个方法简洁明了，但它同样不适合在遍历时修改集合。如果你尝试在

   forEach

   内部修改原始集合，同样会遇到

   ConcurrentModificationException

   。

2. Stream API 的链式操作： 这是 Java 8 集合处理的真正亮点。通过将集合转换为

   Stream

   ，你可以进行一系列的中间操作（如

   filter

   、

   map

   、

   sorted

   等）和终端操作（如

   collect

   、

   reduce

   、

   count

   等）。

   List products = Arrays.asList("Laptop", "Mouse", "Keyboard", "Monitor", "Mouse");
   
   // 筛选出包含 "Mouse" 的产品，并收集到一个新列表
   List mice = products.stream()
                               .filter(p -> p.contains("Mouse"))
                               .collect(Collectors.toList());
   System.out.println("包含 'Mouse' 的产品: " + mice);
   
   // 统计不重复的产品数量
   long distinctProductCount = products.stream()
                                       .distinct()
                                       .count();
   System.out.println("不重复的产品数量: " + distinctProductCount);

   Stream API 的优势在于其表达力、可读性以及对并行处理的良好支持。它鼓励一种“数据管道”的思维，将数据处理过程分解为一系列独立的、可组合的操作。

选择的考量：

在我看来，

Iterator

forEach

如果我的目标只是简单地对每个元素执行一个操作，

forEach

Iterator

Iterator

remove()