当前位置：首页 > news >正文

【Java从入门到入土】04：循环的尽头是递归？不，是Stream！

news 2026/3/27 11:11:21

【Java从入门到入土】04：循环的尽头是递归？不，是Stream！

多数Java开发者对循环的认知，还停留在“能用for/while实现遍历就行”的层面——嵌套for循环写得眼花缭乱，递归求斐波那契数列踩满性能坑，却没意识到：循环的最优解从来不是“写得出来”，而是“写得优雅、跑得高效”。今天拆解传统循环的核心细节、递归的隐藏陷阱，以及为什么现代Java开发中，Stream才是处理循环场景的最优解。

🔍 for循环的四种写法：不止是语法，更是性能差异

for循环是Java最基础的循环形式，但不同写法的性能和适用场景天差地别，选错了可能让代码效率打对折。

1. 基础索引式for循环（数组/ArrayList首选）

// 遍历数组String[]arr={"Java","Stream","Loop"};for(inti=0;i<arr.length;i++){System.out.println(arr[i]);}// 遍历ArrayListList<String>list=newArrayList<>(Arrays.asList(arr));for(inti=0;i<list.size();i++){System.out.println(list.get(i));}

核心特点：直接通过索引访问元素，数组/ArrayList的get(index)是O(1)操作，性能最优；但对LinkedList不友好（get(index)是O(n)，每次都要从头遍历）。
性能坑：别在循环条件里调用list.size()（比如for (int i=0; i<list.size(); i++)）——虽然JIT会优化，但高版本JDK或大数据量下，建议先把长度赋值给变量：int len = list.size(); for(int i=0; i<len; i++)。

2. 增强for循环（for-each，通用写法）

// 遍历任意Collectionfor(Strings:list){System.out.println(s);}

核心特点：底层是迭代器（Iterator），语法简洁，无需关心索引；对LinkedList友好（迭代器遍历是O(n)，比索引遍历快）。
性能点：和迭代器写法性能一致，但代码更简洁；缺点是无法获取当前索引（需手动加计数器），也不能在循环中修改集合（会抛ConcurrentModificationException）。

3. 迭代器式for循环（可控性最高）

Iterator<String>iterator=list.iterator();for(;iterator.hasNext();){Strings=iterator.next();// 支持安全删除元素if(s.equals("Loop")){iterator.remove();}}

核心特点：唯一能在循环中安全删除集合元素的写法（避免并发修改异常）；可控性强，可手动控制迭代进度。
缺点：语法繁琐，日常开发没必要写，仅在需要修改集合时使用。

4. 嵌套for循环（性能重灾区）

// 二维数组遍历（必要的嵌套）int[][]matrix={{1,2},{3,4}};for(inti=0;i<matrix.length;i++){for(intj=0;j<matrix[i].length;j++){System.out.println(matrix[i][j]);}}// 非必要的嵌套（性能陷阱）List<Integer>list1=Arrays.asList(1,2,3);List<Integer>list2=Arrays.asList(4,5,6);// O(n²) 复杂度，大数据量必卡for(Integera:list1){for(Integerb:list2){System.out.println(a+b);}}

核心特点：必要的嵌套（如二维数组）无可避免，但非必要嵌套会导致O(n²)时间复杂度，大数据量下性能暴跌；优化思路是尽量扁平化数据，或用Stream并行处理。

💡 while与do-while：那个“先斩后奏”的循环

while和do-while的核心区别，在于“判断时机”——while是“先判断后执行”，do-while是“先执行后判断”（先斩后奏），这一点直接决定了适用场景。

1. while循环：先审后办

List<String>emptyList=newArrayList<>();// 条件不满足，循环体一次都不执行while(emptyList.iterator().hasNext()){System.out.println("不会执行");}

适用场景：不确定循环次数，且可能一次都不执行的场景（比如遍历可能为空的集合）。

2. do-while循环：先办后审

// 即使条件不满足，循环体也会执行一次do{System.out.println("一定会执行一次");}while(emptyList.iterator().hasNext());// 典型场景：输入验证（至少验证一次）Scannerscanner=newScanner(System.in);Stringinput;do{System.out.println("请输入6位数字密码：");input=scanner.next();}while(!input.matches("\\d{6}"));

适用场景：必须执行至少一次的场景（比如输入验证、初始化操作）；
陷阱：遍历空集合时，do-while会执行一次循环体，容易导致NullPointerException，需提前判空。

🚫 跳出循环：break、continue、return的微妙区别

跳出循环的方式不止break，continue和return也能干预循环流程，但三者的“力度”完全不同，用错了会导致逻辑漏洞。

1. break：跳出当前循环

// 跳出单层循环for(inti=0;i<5;i++){if(i==3){break;// 循环直接终止，后续i=4不会执行}System.out.println(i);// 输出0,1,2}// 跳出外层循环（带标签）outer:for(inti=0;i<3;i++){inner:for(intj=0;j<3;j++){if(j==2){breakouter;// 直接跳出外层循环，而非仅内层}System.out.println(i+","+j);// 输出0,0; 0,1}}

核心：break默认跳出当前循环，带标签可跳出指定外层循环；是终止循环的“精准操作”。

2. continue：跳过当前迭代

for(inti=0;i<5;i++){if(i==3){continue;// 跳过i=3的迭代，继续i=4}System.out.println(i);// 输出0,1,2,4}

核心：不终止循环，仅跳过当前次迭代；注意在do-while中，continue会跳回条件判断处，而非循环体开头。

3. return：直接退出方法

publicstaticvoidloopWithReturn(){for(inti=0;i<5;i++){if(i==3){return;// 直接退出方法，后续代码全不执行}System.out.println(i);// 输出0,1,2}System.out.println("循环结束");// 不会执行}

核心：力度最强，不仅终止循环，还直接退出整个方法；慎用——如果循环后有资源释放（如关闭流、连接），return会导致资源泄漏。

🌀 递归初探：阶乘与斐波那契数列的陷阱

递归常被当作“循环的高级形式”，但多数新手用递归只会踩坑：栈溢出、重复计算，反而比循环更慢。

1. 阶乘的递归实现（栈溢出陷阱）

// 递归求阶乘publicstaticintfactorial(intn){if(n==1)return1;returnn*factorial(n-1);}// 测试：n=1000时，直接抛出StackOverflowErrorpublicstaticvoidmain(String[]args){System.out.println(factorial(1000));}

陷阱：JVM的栈深度有限（默认约1000层），递归深度超过阈值就会栈溢出；即使n=1000，循环写法也能轻松处理，递归却直接崩溃。

2. 斐波那契数列的递归实现（重复计算陷阱）

// 递归求斐波那契数列（第n项）publicstaticintfibonacci(intn){if(n<=2)return1;// 大量重复计算：fib(5)会算fib(4)+fib(3)，fib(4)又算fib(3)+fib(2)，fib(3)被计算两次returnfibonacci(n-1)+fibonacci(n-2);}

性能坑：时间复杂度O(2ⁿ)，n=40时就需要数秒计算；而循环写法的时间复杂度是O(n)，n=10000也能瞬间出结果。

递归的正确定位

递归不是循环的“升级版”，而是“专用工具”——仅适用于树形结构遍历（如二叉树）、分治算法（如快速排序）等“天然递归”的场景；普通的遍历、计算，用递归纯属鸡肋，还容易踩坑。

🔮 前瞻：为什么现代Java更推荐Stream处理循环？

Java 8引入的Stream API，不是“替代循环”，而是“重构循环”——让复杂的循环逻辑（过滤、映射、聚合）变得简洁、可读，还能轻松实现并行处理。

1. 传统循环 vs Stream：代码简洁性对比

需求：过滤出列表中长度大于3的字符串，转大写，统计数量。

// 传统循环写法List<String>list=Arrays.asList("Java","C++","Python","Stream");intcount=0;for(Strings:list){if(s.length()>3){s=s.toUpperCase();count++;}}System.out.println(count);// 输出3// Stream写法longstreamCount=list.stream().filter(s->s.length()>3)// 过滤.map(String::toUpperCase)// 映射.count();// 聚合System.out.println(streamCount);// 输出3

核心优势：Stream采用“声明式编程”，你只需告诉程序“要做什么”（过滤长度>3的字符串），而非“怎么做”（循环、判断、计数），代码可读性提升一个量级。

2. Stream的性能优势：并行处理

对于大数据量（百万级以上），Stream的并行处理（parallelStream）能利用多核CPU，性能远超传统循环：

// 并行Stream处理大数据量List<Integer>bigList=IntStream.range(0,1000000).boxed().collect(Collectors.toList());// 并行过滤+求和，利用多核CPUintsum=bigList.parallelStream().filter(i->i%2==0).mapToInt(Integer::intValue).sum();