Java 游标完全指南：深入理解 Enumeration、Iterator 与 ListIterator

2026-02-14 05:34:14 0条评论 2次阅读 0人点赞

在日常的 Java 开发中，处理集合数据是我们最常面临的任务之一。无论是处理数据库查询的结果集，还是对内存中的列表进行筛选，我们都离不开“遍历”这个操作。你有没有想过，在 Java 的底层，这些遍历机制是如何工作的？为什么有些遍历过程中不能删除元素，而有些又可以？今天，我们将深入探讨 Java 中游标的概念，并通过实战代码，彻底掌握 Enumeration、Iterator 和 ListIterator 的用法与区别。

什么是 Java 游标？

简单来说，Java 游标是用于遍历或迭代集合或流对象中元素的对象。它就像一个指针，指向集合中的某个元素，允许我们逐个访问数据，而无需暴露集合的底层结构。

我们可以把游标想象成在书架上逐本查阅书籍的手指：

  • 顺序访问：它保证了我们可以按顺序访问集合中的每一个元素。
  • 操作能力：某些高级游标（如 ListIterator）不仅允许读取，还允许在遍历过程中安全地添加、移除或替换元素。
  • 类型安全：Java 中的游标通常是泛型的，这意味着我们在编译期就能避免类型转换错误，这比早期的“万能”类型要安全得多。

Java 中的三种游标类型

根据集合类型和支持的操作，Java 主要为我们提供了三种类型的游标。为了让你有一个直观的印象，我们可以通过以下结构图来理解它们的关系：

!Types-of-cursor

这三者各有千秋：

  • Enumeration：元老级人物，主要用于遗留代码，功能单一。
  • Iterator：现代游标的标准，适用于所有集合，支持安全的删除操作。
  • ListIterator：专为 List 设计的增强型游标，支持双向遍历和修改。

接下来，让我们逐一深入剖析它们。

1. 枚举游标

枚举 是 Java 早期的产物（JDK 1.2 之前）。如果你接触过非常古老的 Java 项目，或者使用了像 INLINECODEb1de45e2、INLINECODEd6126c64 这样的遗留类，你可能会遇到它。对于现代开发来说，它主要是为了向后兼容而保留的。

为什么它被称为“只读”？

Enumeration 的主要限制在于它是只读的。这意味着你只能使用它来读取数据，而不能通过它来修改集合（比如删除元素）。此外，它只支持正向遍历。

核心方法

在 java.util.Enumeration 接口中，主要有两个方法：

  • INLINECODE40b96bf8: 测试此枚举是否包含更多元素。如果有，返回 INLINECODEe57a636d。
  • E nextElement(): 如果此枚举对象至少还有一个可提供的元素，则返回该元素的下一个元素。

代码示例：遍历 Vector

让我们看一个实际案例，如何使用 Enumeration 来遍历一个 Vector。请注意，这是经典写法，但在新代码中我们通常更倾向于使用 ArrayList 和 Iterator。

import java.util.Vector;
import java.util.Enumeration;

public class Main {
    public static void main(String[] args) {
        // 创建一个 Vector 集合
        Vector numbers = new Vector();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        // 获取 Vector 的 Enumeration 对象
        Enumeration e = numbers.elements();

        System.out.println("使用 Enumeration 遍历 Vector:");
        // hasMoreElements() 检查是否还有元素
        while (e.hasMoreElements()) {
            // nextElement() 获取下一个元素
            Integer value = e.nextElement();
            System.out.println(value);
            // 注意：这里不能调用 e.remove()，因为 Enumeration 不支持删除
        }
    }
}

输出：

使用 Enumeration 遍历 Vector:
10
20
30

何时使用？

除非你在维护遗留系统，或者使用 INLINECODE126de8ed（其中的 INLINECODEc2e122a3 和 elements() 方法返回 Enumeration），否则在新的开发中建议使用 Iterator。

2. 迭代器游标

从 JDK 1.2 开始，Java 引入了迭代器。这是我们在现代 Java 开发中最常用的游标。它不仅适用于 INLINECODEc3774cb2，还适用于 INLINECODEf574d45d、INLINECODE9e85a67a 以及 INLINECODE8069bf2c 的键值集合。

相比 Enumeration 的优势

为什么我们要放弃 Enumeration 转投 Iterator？主要有以下原因：

  • 统一性：Iterator 是 Java 集合框架的标准成员，所有集合（Collection 接口）都实现了 iterator() 方法。
  • 安全性：这是最重要的一点。Iterator 允许我们在遍历过程中安全地删除元素，而不会引发并发修改异常（ConcurrentModificationException）——前提是你使用 Iterator 自带的 INLINECODEfddd3e7b 方法，而不是集合的 INLINECODE67116fff 方法。
  • 方法名简化：INLINECODEf1573fd2 比 INLINECODEa5404cf6 更简洁。

核心方法

在 java.util.Iterator 接口中，我们需要关注以下方法：

  • boolean hasNext(): 如果仍有元素可以迭代，则返回 true。
  • INLINECODEaa7be7a2: 返回迭代的下一个元素。如果没有下一个元素，抛出 INLINECODEf05ff3d8。
  • default void remove(): 从迭代器指向的集合中移除当前元素（可选操作）。

实战案例：遍历与安全删除

让我们来看一个更贴近实战的例子。假设我们有一个名字列表，我们需要删除其中叫 "Bob" 的名字。

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

public class Main {
    public static void main(String[] args) {
        // 创建一个 ArrayList
        Collection names = new ArrayList();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");

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

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

        System.out.println("
正在迭代并删除 ‘Bob‘...");
        while (iterator.hasNext()) {
            String name = iterator.next(); // 获取下一个元素
            System.out.println("检查元素: " + name);

            // 如果名字是 Bob，则删除
            if (name.equals("Bob")) {
                // 使用迭代器的 remove() 方法删除当前元素
                iterator.remove();
                System.out.println("-> 找到 Bob 并已删除");
            }
        }

        System.out.println("
删除后的列表: " + names);
    }
}

输出：

原始列表: [Alice, Bob, Charlie, David]
正在迭代并删除 ‘Bob‘...
检查元素: Alice
检查元素: Bob
-> 找到 Bob 并已删除
检查元素: Charlie
检查元素: David
删除后的列表: [Alice, Charlie, David]

常见陷阱：并发修改异常

如果你在使用 INLINECODEdc908b10 循环或增强型 INLINECODE852ddaaa 循环遍历集合时，直接调用了 INLINECODE373ec915，程序会立即崩溃抛出 INLINECODE72a83dad。这是因为 Java 迭代器采用了“快速失败”机制，一旦检测到底层数据结构被非法修改，就会立即报错。

错误示范（请勿在代码中这样写）：

// 错误的做法：直接在循环中删除会报错
for (String name : names) {
    if (name.equals("Bob")) {
        names.remove(name); // 抛出 ConcurrentModificationException
    }
}

所以，记住这个规则：遍历时需要修改元素，请务必使用 Iterator 的 remove() 方法。

3. 列表迭代器游标

如果你觉得 Iterator 已经够用了，那是因为你可能还没有遇到过需要“反向遍历”或者“在遍历中替换元素”的需求。列表迭代器 是专门为 List 集合（如 ArrayList, LinkedList）设计的增强型游标，从 JDK 1.2 开始引入。

ListIterator 的独门绝技

ListIterator 扩展了 Iterator 接口，因此它拥有 Iterator 的所有功能，并增加了以下特性：

  • 双向遍历：你可以向前 (INLINECODEda7c0cdd) 也可以向后 (INLINECODE2cee45c8)。
  • 元素索引：你可以获取当前元素的前后索引位置 (INLINECODEe443f93e, INLINECODEda9668f6)。
  • 添加与替换：你可以在遍历时添加新元素 (INLINECODEaa93d3ce) 或替换当前元素 (INLINECODE752e1614)。
  • 修改能力：它不仅能删除，还能动态修改集合结构。

核心方法

在 java.util.ListIterator 接口中，我们需要关注以下方法：

  • INLINECODEf5087487 / INLINECODEd9471863: 正向遍历，同 Iterator。
  • INLINECODEa98aa827 / INLINECODE9adaf5ed: 反向遍历，逆向移动游标并返回元素。
  • INLINECODEf6ae280a: 用指定元素替换 INLINECODEada44081 或 previous() 返回的最后一个元素。
  • void add(E e): 将指定的元素插入列表（插入位置取决于游标当前位置）。

深度实战：正向、反向与修改

让我们通过一个更复杂的例子来展示它的威力。在这个例子中，我们不仅会双向遍历列表，还会在遍历过程中修改数据（例如将 "Java" 替换为 "Java 17"）。

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

public class Main {
    public static void main(String[] args) {
        // 创建一个语言列表
        List languages = new ArrayList();
        languages.add("Java");
        languages.add("Python");
        languages.add("C++");

        // 获取列表迭代器
        ListIterator li = languages.listIterator();

        System.out.println("1. 正向遍历:");
        while (li.hasNext()) {
            String lang = li.next();
            System.out.println("索引 " + li.previousIndex() + ": " + lang);
            
            // 修改元素：如果遇到 Python，我们就把它替换掉
            if (lang.equals("Python")) {
                li.set("Kotlin"); // 将当前元素（next返回的）替换
                System.out.println("  -> 将 Python 替换为 Kotlin");
            }
        }

        System.out.println("
2. 反向遍历:");
        // 现在游标在列表末尾，我们可以反向遍历
        while (li.hasPrevious()) {
            String lang = li.previous();
            System.out.println("索引 " + li.nextIndex() + ": " + lang);
        }

        System.out.println("
最终列表: " + languages);
        
        // 3. 演示添加元素
        // 重置游标到列表开头
        li = languages.listIterator();
        li.next(); // 跳过第一个元素
        li.add("Rust"); // 在当前游标位置（Java之后，Kotlin之前）插入元素
        System.out.println("添加 Rust 后: " + languages);
    }
}

输出：

1. 正向遍历:
索引 0: Java
索引 1: Python
  -> 将 Python 替换为 Kotlin
索引 2: C++

2. 反向遍历:
索引 2: C++
索引 1: Kotlin
索引 0: Java

最终列表: [Java, Kotlin, C++]
添加 Rust 后: [Java, Rust, Kotlin, C++]

实际应用场景

ListIterator 在处理需要回溯或复杂编辑逻辑的场景下非常有用。例如，在文本编辑器中实现“查找并替换”功能时，你可能需要向前找到匹配项，然后再向后检查上下文，这时 ListIterator 的双向特性就派上用场了。

综合对比：如何选择合适的游标？

为了方便你记忆和查阅，我们将这三种游标的特性总结在下面的表格中。这能帮助你在不同的业务场景下做出最优选择。

特性

枚举

迭代器

列表迭代器

:—

:—

:—

:—

引入版本

JDK 1.0 (遗留)

JDK 1.2 (标准)

JDK 1.2 (增强版)

适用范围

仅限遗留类

所有集合 遍历方向

仅正向

仅正向

双向 (正向 & 反向)

读取元素

INLINECODE3610f0d1

INLINECODE8b67b532

INLINECODEc03260c7, INLINECODE3f98de72

修改集合

不支持 (只读)

支持 删除 (INLINECODE0cfe7b60)

支持 删除 (INLINECODE02137548), 替换 (INLINECODE6829498c), 添加 (INLINECODE0c0ed00a)

并发修改

不适用 (通常不修改)

允许通过 INLINECODE8af32b56 安全删除

允许通过 INLINECODE69e56654 安全修改

获取索引

无

无

支持 (INLINECODE1daee47d, INLINECODEff065c20)

安全性

较弱 (类型可选)

强 (泛型)

强 (泛型)## 最佳实践与性能建议

作为经验丰富的开发者，我们不仅要会用，还要知道怎么用得更好。

  • 默认选择 Iterator：在 99% 的通用场景下（如 Set, List, Map 遍历），Iterator 是你的首选。它既安全又简洁。
  • 需要双向或修改时选 ListIterator：如果你在处理 INLINECODE65e1805d，并且需要在遍历中插入或替换元素，不要使用普通的 Iterator，直接使用 INLINECODE3a2ed209 来避免复杂的索引操作。
  • 性能考量：虽然 Iterator 提供了安全性，但在性能极度敏感的循环中，普通的 for (int i=0; i<list.size(); i++) 索引遍历可能会稍微快一点（省去了创建迭代器对象的消耗）。但在现代 JVM 下，这种差异微乎其微，请优先考虑代码的可读性和安全性。
  • Stream API 作为替代：从 Java 8 开始，对于复杂的集合操作，你可以考虑使用 Stream API（stream().forEach(...)）。Stream API 内部本质上也是迭代，但它提供了更高层次的抽象（函数式编程），支持并行处理和链式调用。

总结

今天，我们一起探索了 Java 中的三种游标机制：

  • Enumeration：历史悠久，只读且单向，主要存在于旧代码库中。
  • Iterator：现代集合遍历的标准，提供了安全的删除操作，适用于绝大多数场景。
  • ListIterator：专为 List 设计的“瑞士军刀”，支持双向遍历、插入和替换，是处理复杂列表逻辑的强大工具。

掌握这些底层机制，不仅能让你写出更健壮的代码，还能在遇到 ConcurrentModificationException 时迅速定位问题。下次当你写代码时，不妨停下来思考一下：“我现在使用的游标是最高效的吗？”

希望这篇文章能帮助你更深入地理解 Java 集合框架。继续编码，不断探索！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/48333.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年