外部迭代：你控制循环（for/while/iterator）；内部迭代：库控制循环（Stream、Iterable.forEach）
一、核心定义 & 原理
1. 外部迭代（External Iteration）
代码主动获取迭代器，手动写循环，由调用方控制迭代流程
List<String> list = List.of("A","B","C"); // 增强for底层也是 Iterator 外部迭代 for(String s : list){ System.out.println(s); }底层：Iterator，hasNext()+next()，串行、顺序可控。
- 控制权：开发者
- 迭代行为：拉模式（pull），我们主动拉取下一个元素
- 本质：命令式编程，描述怎么做
2. 内部迭代（Internal Iteration）
把遍历逻辑传给集合 / Stream，框架接管循环，你只传入处理逻辑（Lambda）
List<String> list = List.of("A","B","C"); list.forEach(s -> System.out.println(s)); // Stream 也是内部迭代 list.stream().forEach(System.out::println);底层：Consumer回调，框架遍历元素，推模式（push），框架把元素推给你的函数
- 控制权：类库 / 运行时
- 迭代行为：推模式，库把元素推给回调
- 本质：声明式编程，描述做什么
二、对比表
表格
| 维度 | 外部迭代 | 内部迭代 (Stream/forEach) |
|---|---|---|
| 编程范式 | 命令式 | 声明式 |
| 循环控制权 | 开发者手动控制 | JDK 库内部控制 |
| 并行能力 | 手动写多线程，容易出错 | parallelStream()一键并行（底层 ForkJoin） |
| 断点调试 | 逐行看循环，直观 | 回调内断点，看不到循环栈 |
| 元素操作 | 可 break/continue/return | 不能直接 break、continue |
| 可变外部变量 | 可以读写 | Lambda 只能捕获 effectively final 变量 |
| 性能 | 简单循环开销极小 | 有少量函数调用开销；并行大数据才赚回来 |
| 可组合性 | 多个操作嵌套循环，代码臃肿 | 链式调用：filter/map/sorted，易组合 |
三、关键原理细节
✅ 外部迭代：Iterator
Iterable接口只有一个方法iterator()，返回迭代器。
public interface Iterator<E> { boolean hasNext(); E next(); default void remove(); }增强 for 循环只是语法糖，编译后就是Iterator调用。
缺点：迭代和处理逻辑耦合，多个过滤转换要多层嵌套，很难自动并行。
✅ 内部迭代：Stream 不是容器
Stream不存储数据，它是操作流水线。
- 中间操作（filter/map）：懒加载，只组装流水线，不执行
- 终端操作（forEach/collect）：触发真正遍历（内部迭代开始）
parallelStream()内部迭代会自动拆分数据分片，ForkJoin 并行执行，外部迭代很难做到同等简洁。
四、实战避坑（高频踩坑点）
坑 1：内部迭代不能 break /continue
// ❌ 编译报错 list.stream().forEach(s->{ if("B".equals(s)) break; // break 不属于循环上下文！ });✅ 替代方案：
- 用
takeWhile（Java9+）：流满足条件就截断
list.stream().takeWhile(s->!"B".equals(s)).forEach(System.out::println);- 用 filter 过滤；或者换回外部迭代（需要提前中断时优先外部迭代）
坑 2：Lambda 捕获变量必须 effectively final
int count = 0; list.stream().forEach(s->{ count++; // ❌ 编译错误，count不是final });✅ 方案：用原子类AtomicInteger；或者外部迭代
原理：Lambda 捕获的是变量快照，不是变量引用，不允许修改基础类型变量。
坑 3：parallelStream 并行内部迭代的坑
- 非线程安全集合collect 会并发异常；
- 操作有顺序依赖（比如顺序累加），并行结果错乱；
- 并行有开销：小数据集不要用 parallelStream，线程调度开销 > 收益；
- 不要在并行流里操作共享可变状态。
口诀：大数据、无状态、无顺序依赖 → 并行；小数据 / 顺序敏感 → 串行流 / 外部迭代
坑 4：内部迭代调试难
Stream 链式代码，断点只能停在 lambda 内部，看不到遍历流程。 👉 技巧：调试可以临时换成外部迭代，或者用peek()打印日志。
坑 5：forEach 内部迭代，不要修改原集合
不管外部 / 内部迭代，遍历中修改集合（add/remove）大概率触发ConcurrentModificationException。 Stream 同样会抛 CME。
坑 6：性能误区
很多人以为 Stream 一定慢：
- 少量元素：外部迭代略快（Stream 有函数调用、流水线创建开销）
- 百万级大数据：并行内部迭代优势明显 JIT 会对简单 Lambda 做内联优化，很多场景差距很小。优先可读性，不要过早优化。
五、怎么选？决策清单
✅ 优先内部迭代（Stream）：
- 需要多个连续操作：filter、map、distinct、sorted、collect
- 代码希望简洁声明式，减少循环样板代码
- 大数据，考虑并行处理
- 不需要中途 break/continue
✅ 优先外部迭代（for/Iterator）：
- 需要提前中断循环（break）、continue
- 非常简单的单层循环，追求极致性能
- 复杂迭代控制（多个游标，双向遍历）
- 调试困难，需要清晰循环栈
六、代码对比示例：过滤 + 收集
外部迭代：
List<String> res = new ArrayList<>(); for(String s : list){ if(s.length()>1){ res.add(s.toUpperCase()); } }内部迭代：
List<String> res = list.stream() .filter(s -> s.length()>1) .map(String::toUpperCase) .collect(Collectors.toList());七、一句话总结
外部迭代：你指挥循环，适合精细控制、提前中断；内部迭代：库指挥循环，适合链式数据处理、声明式写法，大数据可并行，但无法 break，捕获变量有限制。
