Java面试官-既然有了For循环，为什么还要有forEach操作呢？

作为 Java 开发者，你是不是常常遇到这样的场景：遍历一个 List 集合时，手指悬在键盘上犹豫 —— 到底用传统的 For 循环，还是简洁的 ForEach？有人说 ForEach 代码更简洁，写起来省时间；有人说 For 循环性能更好，还能灵活操作索引；甚至有人踩过坑：用 ForEach 遍历删除元素时突然报
ConcurrentModificationException，换成 For 循环就安然无恙。

明明都是循环遍历，为什么会有这么多差异？什么时候该用 For 循环，什么时候该选 ForEach？这两个常用语法的核心区别和适用场景，实则藏着许多 Java 开发者容易忽略的细节，今天就一次性给大家说透！

两种循环的技术本质的是什么？

在聊区别之前，我们先搞清楚这两种循环的技术背景和设计初衷，理解它们的 “底层逻辑”：

1. 传统 For 循环（索引循环）

For 循环是 Java 语言诞生之初就存在的基础语法，核心结构为：

for (int i = 0; i < list.size(); i++) {
    String item = list.get(i);
    // 业务逻辑
}

它的本质是通过索引访问集合元素，依赖于集合的 “随机访问能力”—— 列如 ArrayList 底层是数组结构，通过索引 i 可以直接定位到元素，时间复杂度为 O (1)。这种循环设计的核心优势是 “灵活控制”，开发者可以自主决定循环的起始位置、步长，甚至中途修改索引。

2. ForEach 循环（增强 for 循环）

ForEach 循环是 Java 5 引入的语法糖，核心结构为：

for (String item : list) {
    // 业务逻辑
}

它的本质是迭代器（Iterator）遍历，编译后会被转换成迭代器的 hasNext () 和 next () 方法调用。这种设计的初衷是 “简化遍历代码”，让开发者无需关注索引细节，专注于业务逻辑。但它依赖于集合实现 Iterable 接口，对于没有迭代器支持的容器（如普通数组），编译器会自动转换成传统 For 循环。

这里要注意一个关键知识点：ForEach 循环并不是独立的遍历机制，而是迭代器或传统循环的 “语法简化版”，这也是它和传统 For 循环核心差异的根源。

3 大核心区别 + 场景化选择指南

搞懂了底层逻辑，我们从实际开发场景出发，拆解两种循环的核心区别，帮你快速判断 “该用谁”：

1. 语法简洁度：ForEach 更胜一筹

传统 For 循环需要声明索引变量、循环条件、步长递增，代码相对繁琐；而 ForEach 直接遍历元素，代码简洁直观，减少了索引操作的冗余代码，也降低了因索引计算错误（如 i++ 写成 i–）导致的 bug。

示例对比：遍历一个 ArrayList 集合

传统 For 循环：

List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add("王五");
// 传统For循环
for (int i = 0; i < names.size(); i++) {
    System.out.println("姓名：" + names.get(i));
}

ForEach 循环：

List<String> names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add("王五");
// ForEach循环
for (String name : names) {
    System.out.println("姓名：" + name);
}

结论：如果只是简单遍历元素，无需操作索引，ForEach 是更优选择，代码更简洁易读。

2. 功能灵活性：For 循环碾压 ForEach

这是两种循环最核心的区别！传统 For 循环的 “索引控制” 能力，是 ForEach 无法替代的，主要体目前 3 个场景：

（1）需要操作索引时

列如遍历集合时需要获取元素的下标（如排行榜展示名次）、修改指定索引的元素、逆序遍历等场景，传统 For 循环可以直接通过索引实现，而 ForEach 无法获取索引（除非手动声明计数器，反而冗余）。

示例：逆序遍历集合并输出索引

// 传统For循环（支持逆序）
for (int i = names.size() - 1; i >= 0; i--) {
    System.out.println("第" + (i+1) + "名：" + names.get(i));
}

// ForEach（需手动加计数器，繁琐）
int index = 0;
for (String name : names) {
    System.out.println("第" + (index+1) + "名：" + name);
    index++;
}

（2）需要中途修改循环结构时

列如遍历集合时删除元素、跳过指定元素、修改循环步长（如 i += 2 每隔一个元素遍历）等场景，传统 For 循环可以灵活控制。而 ForEach 由于依赖迭代器，遍历过程中修改集合结构（如 add/remove 元素）会触发
ConcurrentModificationException（快速失败机制）。

反例（ForEach 删除元素报错）：

// 错误示例：ForEach遍历删除元素，会报ConcurrentModificationException
for (String name : names) {
    if (name.equals("李四")) {
        names.remove(name); // 报错！
    }
}

// 正确示例：传统For循环删除元素（需注意索引递减）
for (int i = 0; i < names.size(); i++) {
    if (names.get(i).equals("李四")) {
        names.remove(i);
        i--; // 避免删除后索引跳过下一个元素
    }
}

（3）遍历普通数组时

虽然 ForEach 也支持遍历数组，但传统 For 循环可以更灵活地控制数组的遍历范围（如只遍历前 5 个元素），而 ForEach 只能完整遍历数组。

结论：如果需要操作索引、修改循环结构或灵活控制遍历范围，必须用传统 For 循环；ForEach 仅适用于 “只读遍历” 场景。

3. 性能差异：分集合类型讨论（关键！）

许多开发者误以为 “For 循环必定比 ForEach 快”，但实际性能差异取决于集合的底层实现，不能一概而论：

（1）随机访问集合（如 ArrayList）

ArrayList 底层是数组，支持随机访问（get (i) 时间复杂度 O (1)）。此时传统 For 循环和 ForEach 性能差异极小 ——ForEach 本质是迭代器遍历，迭代器需要维护游标状态，理论上略慢于直接索引访问，但在实际开发中（数据量≤10 万），这种差异可以忽略不计。

实测数据（遍历 10 万条 String 数据，JDK 11 环境）：

传统 For 循环：平均耗时 7.8ms
ForEach 循环：平均耗时 8.5ms

（2）非随机访问集合（如 LinkedList）

LinkedList 底层是双向链表，不支持随机访问（get (i) 需要从头节点遍历到第 i 个节点，时间复杂度 O (n)）。此时传统 For 循环的性能会急剧下降 —— 遍历 10 万条数据时，传统 For 循环需要重复执行 get (i)，总时间复杂度为 O (n²)；而 ForEach 通过迭代器遍历，只需一次遍历链表，时间复杂度为 O (n)。

实测数据（遍历 10 万条 String 数据，JDK 11 环境）：

传统 For 循环：平均耗时 1280ms
ForEach 循环：平均耗时 9.2ms

结论：

遍历 ArrayList 等随机访问集合：两种循环性能差异可忽略，优先按代码简洁度选择；
遍历 LinkedList 等非随机访问集合：坚决用 ForEach，避免传统 For 循环的性能灾难。

总结：一张表搞定循环选择

最后用一张表总结两种循环的核心区别和适用场景，提议收藏备用：

对比维度	传统 For 循环	ForEach 循环
语法简洁度	繁琐（需写索引逻辑）	简洁（直接遍历元素）
性能表现	随机访问集合（ArrayList）：优；非随机访问集合（LinkedList）：差	随机访问集合：略差；非随机访问集合：优
异常风险	无（手动控制索引）	遍历中修改集合：报 ConcurrentModificationException