从入门到进阶，逐步梳理 9 种常见的 for 循环效率优化技巧

前言

在 Java 开发中，for 循环是最常见的遍历与重复计算方式之一。对于元素众多或耗时操作，写法不当很容易造成性能瓶颈。本文将从入门到进阶，逐步梳理 9 种常见的 for 循环优化技巧，并结合场景分析优缺点，帮助你写出既易读又高效的代码。

一、案例背景：初始化一个集合

List<String> list = new ArrayList<>();
// … 向 list 中添加若干元素 …

下面以对 list 中每个元素打印为例，探讨不同写法的性能差异及适用场景。

二、9 种 for 循环优化方式对比

方法一：最常规的写法

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

• 优点：最直观、易于理解。
• 缺点：每次循环都要调用 list.size()，当 size() 较复杂（如 LinkedList）或循环次数巨大时，会带来额外开销。

方法二：将长度提取到外部变量（作用域较大）

int m = list.size();
for (int i = 0; i < m; i++) {
    System.out.println(list.get(i));
}

• 优点：避免重复调用 size()。
• 缺点：变量 m 作用域过大（在整个方法内都可见），违背最小作用域原则；无法在循环中动态修改 list 长度（增删元素）。

方法三：在 for 头部定义长度变量（最佳实践）

for (int i = 0, n = list.size(); i < n; i++) {
    System.out.println(list.get(i));
}

• 优点：

  1. 只调用一次 size()；
  2. 变量 n 作用域仅限于循环头部，符合最小作用域原则。

• 缺点：同样不允许在循环体内修改 list 大小。

方法四：倒序遍历

for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

• 优点：只调用一次 size()，变量作用域同样最小；正序或倒序均省去重复计算长度。

• 缺点：

  1. 输出顺序与正序相反；
  2. 可读性稍差，不适用于对顺序敏感的场景。

• 适用场景：仅对元素校验、批量删除等与顺序无关的操作。

方法五：使用 Iterator 遍历

for (Iterator<String> it = list.iterator(); it.hasNext();) {
    System.out.println(it.next());
}

• 优点：通用性强，支持安全地在遍历期间删除元素；适用于各种 Collection 实现。
• 缺点：语法稍繁琐；访问元素时需要调用 next()，在性能极度敏感场景下略逊。

方法六：增强型 for（JDK 1.5+）

for (String s : list) {
    System.out.println(s);
}

• 优点：语法最简洁，结合泛型可消除强制类型转换；阅读体验最佳。
• 缺点：同样不支持在循环中改变集合大小；对于需要获取下标 i 的场景，需额外维护计数器。

方法七：循环嵌套选“外小内大”原则

// 不推荐：大循环在外，小循环在内，频繁执行内层逻辑
for (int i = 0; i < 10000; i++) {
    for (int j = 0; j < 10; j++) {
        // …
    }
}

// 推荐：把常量循环放在外层
for (int j = 0; j < 10; j++) {
    for (int i = 0; i < 10000; i++) {
        // …
    }
}

• 原理：固定次数少的循环放外层，可减少内层循环的启动及索引维护开销。
• 适用场景：当内外层循环次数差异巨大时明显有效。

方法八：将不变运算提取到循环外

// 前：每次都计算 a*b
for (int i = 0; i < 10; i++) {
    int result = i * a * b;
    // …
}

// 后：只算一次
int c = a * b;
for (int i = 0; i < 10; i++) {
    int result = i * c;
    // …
}

• 优点：将与循环变量无关的计算剥离到外部，减少重复计算。
• 缺点：仅针对昂贵的“常量运算”有效。

方法九：将异常处理移到循环外

// 反例：异常捕获每次都要设置
for (int i = 0; i < 10; i++) {
    try {
        // …
    } catch (Exception e) {
        // …
    }
}

// 正例：一次 try 块包裹循环
try {
    for (int i = 0; i < 10; i++) {
        // …
    }
} catch (Exception e) {
    // …
}

• 优点：减少每次循环都要创建异常处理块的开销；逻辑更清晰。
• 适用场景：当循环体内抛出异常概率极低，且希望统一处理时。

三、综合示例对比

// 常规写法 vs. 最佳写法对比
// 数据准备
List<Integer> data = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    data.add(i);
}

// 方案 A：常规 size() 调用
long t1 = System.currentTimeMillis();
for (int i = 0; i < data.size(); i++) {
    // 模拟耗时
    int x = data.get(i) * 2;
}
System.out.println("方案A耗时：" + (System.currentTimeMillis() - t1));

// 方案 B：size 提前读取
long t2 = System.currentTimeMillis();
for (int i = 0, n = data.size(); i < n; i++) {
    int x = data.get(i) * 2;
}
System.out.println("方案B耗时：" + (System.currentTimeMillis() - t2));

通常方案 B 相比方案 A 能提升 ~5%–10% 的执行效率（视 JVM 优化而定）。

四、注意事项与最佳实践

1. 可读性优先
   除在超大数据量或性能关键场景，增强 for 循环或 Iterator 通常已足够，阅读性更佳。
2. 合理剖析瓶颈
   在未做性能测试前，避免过早微优化；使用 Benchmark、Profiler 等工具定位真正瓶颈。
3. 并行流与并发
   对于 CPU 密集型任务，可考虑 Java 8 并行流（parallelStream()）或 Fork/Join 框架，但须注意线程开销与共享资源竞争。
4. 集合选型
   对于频繁索引访问，优先使用 ArrayList；对频繁增删，可考虑 LinkedList、CopyOnWriteArrayList 或 ConcurrentLinkedDeque。

结语

本文系统梳理了 9 种 for 循环优化方式，从最基础的减少 size() 调用，到提取不变运算和异常处理，再到循环嵌套的设计原则。希望你在日常开发中，既能保持代码简洁易读，也能在性能关键场景中做出恰当优化，让程序跑得更快、跑得更稳。