Java 迭代器接口详解：从 Iterator 到 ListIterator 的完整指南

白山编程大哥2026-09-06 14:14

1. 引言

在 Java 集合框架中，迭代器（Iterator）是遍历集合元素的核心接口。无论是 ArrayList、HashSet 还是 HashMap，都可以通过迭代器统一地访问其中的元素，而不必关心底层数据结构的具体实现。本文将深入讲解 Java 迭代器接口的设计原理、常用方法、实现机制以及实际应用场景，帮助你彻底掌握这一重要知识点。

2. Iterator 接口概述

Iterator 接口位于 java.util 包中，是 Java 集合框架的根接口之一。它提供了一种统一的方式来遍历集合中的元素，屏蔽了不同集合底层实现的差异。

2.1 接口定义

java 复制代码 
public interface Iterator<E> {
    boolean hasNext();    // 判断是否还有下一个元素
    E next();             // 返回下一个元素
    default void remove() { throw new UnsupportedOperationException(); }
    default void forEachRemaining(Consumer<? super E> action) { ... }
}

2.2 核心方法说明

方法 返回值 作用
hasNext() boolean 判断集合中是否还有未遍历的元素
next() E 返回迭代器当前位置的下一个元素，并将指针后移
remove() void 从集合中移除迭代器最后返回的元素（可选操作）
forEachRemaining() void 对剩余所有元素执行指定操作（Java 8 新增）

3. 迭代器的基本使用

3.1 标准遍历模式

java 复制代码 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");

        // 使用迭代器遍历
        Iterator<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
    }
}

3.2 使用 forEachRemaining 简化遍历

java 复制代码 
Iterator<String> iterator = fruits.iterator();
iterator.forEachRemaining(System.out::println);

3.3 迭代器与增强 for 循环的关系

增强 for 循环（for-each）本质上就是迭代器的语法糖：

java 复制代码 
// 增强 for 循环
for (String fruit : fruits) {
    System.out.println(fruit);
}

// 等价于迭代器写法
Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}

4. 迭代器遍历时的删除操作

4.1 使用迭代器的 remove 方法

java 复制代码 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorRemoveDemo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }

        // 删除所有偶数
        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            if (num % 2 == 0) {
                iterator.remove();  // 安全删除
            }
        }

        System.out.println(numbers);  // 输出: [1, 3, 5, 7, 9]
    }
}

4.2 为什么不能在遍历时直接调用集合的 remove

java 复制代码 
// 错误示例：会抛出 ConcurrentModificationException
for (Integer num : numbers) {
    if (num % 2 == 0) {
        numbers.remove(num);  // 抛出异常！
    }
}

这是因为集合内部维护了一个 modCount（修改次数）计数器，迭代器在创建时会记录当前的 modCount。当集合结构被直接修改时，modCount 会变化，迭代器检测到不一致就会抛出 ConcurrentModificationException。

4.3 使用 remove 方法的注意事项

  • 在调用 remove() 之前必须先调用 next()，否则会抛出 IllegalStateException
  • remove() 只能移除迭代器最后返回的元素
  • 并非所有集合都支持 remove() 操作，不支持时会抛出 UnsupportedOperationException

5. ListIterator 接口

ListIterator 是 Iterator 的子接口，专门用于 List 类型的集合，提供了双向遍历和元素修改的能力。

5.1 接口定义

java 复制代码 
public interface ListIterator<E> extends Iterator<E> {
    boolean hasPrevious();    // 是否有前一个元素
    E previous();             // 返回前一个元素
    int nextIndex();          // 返回下一个元素的索引
    int previousIndex();      // 返回前一个元素的索引
    void set(E e);            // 替换最后返回的元素
    void add(E e);            // 在当前位置插入元素
}

5.2 双向遍历示例

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("A");
        list.add("B");
        list.add("C");

        // 正向遍历
        ListIterator<String> iterator = list.listIterator();
        System.out.println("正向遍历:");
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");  // A B C
        }

        // 反向遍历
        System.out.println("\n反向遍历:");
        while (iterator.hasPrevious()) {
            System.out.print(iterator.previous() + " ");  // C B A
        }
    }
}

5.3 使用 ListIterator 修改元素

java 复制代码 
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if ("B".equals(element)) {
        iterator.set("BB");  // 将 B 替换为 BB
    }
}
System.out.println(list);  // 输出: [A, BB, C]

6. 迭代器的 fail-fast 机制

6.1 什么是 fail-fast

fail-fast（快速失败）是 Java 集合框架的一种错误检测机制。当多个线程同时对集合进行结构性修改时，迭代器会立即抛出 ConcurrentModificationException，而不是在将来某个不确定的时间点出现问题。

6.2 触发条件

java 复制代码 
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");

Iterator<String> iterator = list.iterator();
list.add("C");  // 结构性修改

while (iterator.hasNext()) {
    System.out.println(iterator.next());  // 抛出 ConcurrentModificationException
}

6.3 如何避免 fail-fast

  • 单线程环境下，使用迭代器的 remove() 方法而不是集合的 remove() 方法
  • 多线程环境下，使用 CopyOnWriteArrayList 等并发容器
  • 使用 Collections.synchronizedList() 包装集合

7. 自定义迭代器实现

7.1 实现 Iterable 接口

java 复制代码 
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyCollection<T> implements Iterable<T> {
    private Object[] elements;
    private int size;

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

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

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private int currentIndex = 0;

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

            @Override
            @SuppressWarnings("unchecked")
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return (T) elements[currentIndex++];
            }
        };
    }

    public static void main(String[] args) {
        MyCollection<String> collection = new MyCollection<>(5);
        collection.add("Java");
        collection.add("Python");
        collection.add("Go");

        for (String lang : collection) {
            System.out.println(lang);
        }
    }
}

7.2 迭代器设计原则

  • 迭代器应该独立于集合的存储结构
  • 迭代器应该支持快速失败机制
  • 迭代器应该实现 Iterable 接口以支持增强 for 循环

8. 迭代器与 Stream 的对比

特性 Iterator Stream
遍历方式 外部迭代 内部迭代
是否可复用 不可复用 不可复用
支持函数式操作 不支持 支持
惰性求值 不支持 支持
并行处理 不支持 支持
java 复制代码 
// 使用 Stream 替代迭代器
List<String> result = fruits.stream()
    .filter(s -> s.length() > 2)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

9. 常见问题与最佳实践

9.1 常见问题

  1. ConcurrentModificationException：遍历时修改集合结构
  2. NoSuchElementException ：调用 next() 时没有检查 hasNext()
  3. IllegalStateException ：调用 remove() 前没有调用 next()

9.2 最佳实践

  • 遍历时删除元素，优先使用迭代器的 remove() 方法
  • 使用增强 for 循环简化代码，但需要删除时使用显式迭代器
  • 多线程环境下使用并发集合类
  • 优先使用 Stream API 处理复杂的数据操作

10. 总结

迭代器是 Java 集合框架中不可或缺的组成部分，它提供了一种统一、安全的方式来遍历集合元素。通过本文的学习，我们掌握了：

  • Iterator 接口的核心方法及其使用场景
  • ListIterator 的双向遍历和元素修改能力
  • fail-fast 机制的原理和避免方法
  • 自定义迭代器的实现方式
  • 迭代器与 Stream API 的对比和选择

在实际开发中，合理选择遍历方式能够提高代码的可读性和性能。希望本文能帮助你更好地理解和使用 Java 迭代器接口。

相关推荐
热心网友俣先生1 小时前
2026国赛C题：五年命题规律与预测
java·c语言·前端·数学建模
见叶之秋1 小时前
【C++】String类的使用（含模拟实现）
java·开发语言·c++
想吃火锅10051 小时前
【leetcode】42.接雨水js
开发语言·javascript·ecmascript
一叶龙洲1 小时前
Ubuntu从图标到卸载应用
linux·windows·ubuntu
江湖人称菠萝包2 小时前
【Windows】《深入浅出Windows API程序设计：编程基础篇》笔记-Chapter2-Windows窗口程序
windows·笔记
竹叶青_七弦2 小时前
从复制粘贴到Harness：Java后端AI编程的工程化之路
java
wuminyu2 小时前
Linux内核线程调度与虚拟线程调度机制系统级深度剖析
java·linux·c语言·jvm·c++
小溪学编程2 小时前
Java InputStream 详解：从基础到实战
java·python·php
血小板要健康2 小时前
队列 + 宽搜（BFS）：二叉树层序遍历 算法总结
java·数据结构·笔记·算法·leetcode·宽度优先
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接04ZCode 周末送额度活动开启：3 亿 Token 免费领取05历年考研数学一、数学二、数学三真题试卷及答案PDF062026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？07微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路10VSCode+CodeX扩展，无法启动