Java 中 for 和 foreach 效率的思考

最新推荐文章于 2025-09-24 14:00:00 发布
原创 最新推荐文章于 2025-09-24 14:00:00 发布 · 1.9k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#for and foreach #for 和 foreach #for foreach 效率 #数组遍历效率

序

算是解放了吧，离开了独立生活了近一年的城市，再多的不舍还是抵不过家的温暖。要是还是一年前的自己，可能此时的心态应该是放飞自我，约上几个朋友都不知道在哪里吃着宵夜了。现在更多的是亲情的陪伴。回来第一天晚上，发现自己对于熬夜这件事情是越来越执着了，最近在看些值得一看的影视作品《亮剑》、《让子弹飞》、《好先生》等等，不是说自己有多闲，只是觉得对于生活的思考还是很欠缺的。还是那句话：努力的人，自带光芒。加油！

晚上趁着空闲，捋了一下学习路线。参考一些大牛的技术博客的时候看到这样一句话：尽管基础再差，如果能够在写代码的时候，能把阿里巴巴代码规范插件中的所有警告让他们全部闭嘴的话，一定时间积累下来，水平也不会差到那里去。 寻思是否有那么神奇，那就试试呗，有效就成神，没有就算了呗，当下时间真是个不值钱的东西。

传说的神奇插件，就是这玩意（看图）：
阿里巴巴代码规范插件

Question

嘿嘿~~~发现一个比较有趣的问题，是发现阿里巴巴的代码规范插件给出警告说，for 语句可以换成 foreach，如图：
for replace with foreach
我就纳闷了，为啥要换呢？阿里巴巴代码规范是为了干嘛，肯定是效率啊，那就先把运行时间打印出来。一顿操作猛如虎，代码如图：

public static void main(String[] args) {
     System.out.println("Hello World!");
     int[][] list = new int[3][4];
     for (int i = 0; i < list.length; i++) {
         for (int j = 0; j < list[i].length; j++) {
             list[i][j] = i * 10 + j;
         }
     }

     System.out.println("--------比较 for or foreach运行效率---------");
     System.out.println("#### for 运行结果 ---->>>>>");
     long startTime1 = System.nanoTime();
     for (int first = 0; first < list.length; first++) {
         for (int second = 0; second < list[first].length; second++) {
             System.out.print(list[first][second] + "\t");
         }
         System.out.println();
     }
     long endTime1 = System.nanoTime();
     System.out.println("程序运行时间： " + (endTime1 - startTime1) + "us");

     System.out.println("#### foreach 运行结果 ---->>>>>");
     long startTime2 = System.nanoTime();
     for (int[] i : list) {
         for (int j : i) {
             System.out.print(j + "\t");
         }
         System.out.println();
     }
     long endTime2 = System.nanoTime();
     System.out.println("程序运行时间： " + (endTime2 - startTime2) + "us");
 }

好了，看下运行结果（意料之中）：

--------比较 for or foreach运行效率---------
#### for 运行结果 ---->>>>>
20	21	22	23	
10	11	12	13	
0	1	2	3	
程序运行时间： 196400us
#### foreach 运行结果 ---->>>>>
20	21	22	23	
10	11	12	13	
0	1	2	3	
程序运行时间： 139700us

结果竟然差这么多，震惊！！！

刨根问底

效率差距如此之大，难怪插件会提示替换。但是为啥呢，有位老铁说可能是：“是否小于那个条件那里，那里判断估计是占了一些时间”。既然如此，那就尝试下在 foreach 中添加“等价”的判断（随便添加个 if 语句就算了，技术水平限制只能尽可能的模拟相似）。那就来吧，直接贴代码：

public static void main(String[] args) {
    System.out.println("Hello World!");
    int[][] list = new int[3][4];
    for (int i = 0; i < list.length; i++) {
        for (int j = 0; j < list[i].length; j++) {
            list[i][j] = i * 10 + j;
        }
    }
    
    System.out.println("--------比较 for or foreach运行效率---------");
    System.out.println("#### for 运行结果 ---->>>>>");
    long startTime1 = System.nanoTime();
    for (int first = 0; first < list.length; first++) {
        for (int second = 0; second < list[first].length; second++) {
            System.out.print(list[first][second] + "\t");
        }
        System.out.println();
    }
    long endTime1 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime1 - startTime1) + "us");

    System.out.println("#### foreach 运行结果 ---->>>>>");
    long startTime2 = System.nanoTime();
    for (int[] i : list) {
        // 添加判断语句
        if (list.length > 0);
        for (int j : i) {
            System.out.print(j + "\t");
            // 添加判断语句
            if (list.length > 0);
        }
        System.out.println();
    }
    long endTime2 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime2 - startTime2) + "us");
}

运行结果：

--------比较 for or foreach运行效率---------
#### for 运行结果 ---->>>>>
20	21	22	23	
10	11	12	13	
0	1	2	3	
程序运行时间： 261000us
#### foreach 运行结果 ---->>>>>
20	21	22	23	
10	11	12	13	
0	1	2	3	
程序运行时间： 106500us

从结果看，似乎与 for 的条件判断有点关系，但是究竟是不是因为这个关系呢，我们看下编译产生的.class文件，直接贴代码：

public static void main(String[] args) {
    System.out.println("Hello World!");
    int[][] list = new int[3][4];
    int j;
    for(int i = 0; i < list.length; ++i) {
        for(j = 0; j < list[i].length; ++j) {
            list[i][j] = i * 10 + j;
        }
    }
    System.out.println("--------比较 for or foreach运行效率---------");
    System.out.println("#### for 运行结果 ---->>>>>");
    long startTime1 = System.nanoTime();
    for(first = 0; first < list.length; ++first) {
        for(int second = 0; second < list[first].length; ++second) {
            System.out.print(list[first][second] + "\t");
        }
        System.out.println();
    }
    long endTime1 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime1 - startTime1) + "us");
    System.out.println("#### foreach 运行结果 ---->>>>>");
    long startTime2 = System.nanoTime();
    int[][] var8 = list;
    int var9 = list.length;
    for(int var10 = 0; var10 < var9; ++var10) {
        int[] i = var8[var10];
        if (list.length > 0) {
        }
        int[] var12 = i;
        int var13 = i.length;
        for(int var14 = 0; var14 < var13; ++var14) {
            int j = var12[var14];
            System.out.print(j + "\t");
            if (list.length > 0) {
            }
        }
        System.out.println();
    }
    long endTime2 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime2 - startTime2) + "us");
}

其实通过.class文件可以一目了然的看出来，foreach 在编译过程中也是转换成 for 的运行的，所以上述假设并不成立。但是发现了一个问题，foreach 在编译的时候会转化成 for 而且编译生成的 for 与自己写的有点不一样，如果按照编译生成的来写，效果会怎样呢？
废话不多说，直接贴代码：

public static void main(String[] args) {
    System.out.println("Hello World!");
    int[][] list = new int[3][4];
    for (int i = 0; i < list.length; i++) {
        for (int j = 0; j < list[i].length; j++) {
            list[i][j] = i * 10 + j;
        }
    }
    System.out.println("--------比较 for or foreach运行效率---------");
    System.out.println("#### for 运行结果 ---->>>>>");
    long startTime1 = System.nanoTime();
    // 改写的代码
    int[][] var8 = list;
    int var9 = list.length;
    for(int var10 = 0; var10 < var9; ++var10) {
        int[] i = var8[var10];
        int[] var12 = i;
        int var13 = i.length;
        for(int var14 = 0; var14 < var13; ++var14) {
            int j = var12[var14];
            System.out.print(j + "\t");
        }
        System.out.println();
    }
    long endTime1 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime1 - startTime1) + "us");
    System.out.println("#### foreach 运行结果 ---->>>>>");
    long startTime2 = System.nanoTime();
    for (int[] i : list) {
        // 添加判断语句
          if (list.length > 0);
        for (int j : i) {
            System.out.print(j + "\t");
            // 添加判断语句
              if (list.length > 0);
        }
        System.out.println();
    }
    long endTime2 = System.nanoTime();
    System.out.println("程序运行时间： " + (endTime2 - startTime2) + "us");
}

运行结果：

--------比较 for or foreach运行效率---------
#### for 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 412800us
#### foreach 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 103400us

结果还是 for 耗时长，对比下.class文件，代码如下：

System.out.println("--------比较 for or foreach运行效率---------");
System.out.println("#### for 运行结果 ---->>>>>");
long startTime1 = System.nanoTime();
int[][] var8 = list;
int var9 = list.length;
int j;
for(int var10 = 0; var10 < var9; ++var10) {
    int[] i = var8[var10];
    int[] var12 = i;
    int var13 = i.length;
    for(int var14 = 0; var14 < var13; ++var14) {
        j = var12[var14];
        System.out.print(j + "\t");
    }
    System.out.println();
}

long endTime1 = System.nanoTime();
System.out.println("程序运行时间： " + (endTime1 - startTime1) + "us");
System.out.println("#### foreach 运行结果 ---->>>>>");
long startTime2 = System.nanoTime();
int[][] var21 = list;
j = list.length;
for(int var12 = 0; var12 < j; ++var12) {
    int[] i = var21[var12];
    int[] var14 = i;
    int var15 = i.length;
    for(int var16 = 0; var16 < var15; ++var16) {
        int j = var14[var16];
        System.out.print(j + "\t");
    }
    System.out.println();
}
long endTime2 = System.nanoTime();
System.out.println("程序运行时间： " + (endTime2 - startTime2) + "us");

基本无异，但是仔细看下来，会发现，其实在 for 中定义的变量 j 在 foreach 中也有使用，详细看图：
j变量
这部分已经涉及知识的盲区了，但是我有个大胆的想法，既然有变量复用，那是不是意味着跟编译顺序有关系？废话不多说，直接运行几次，看结果：

  • 第一次结果：
--------比较 for or foreach运行效率---------
#### foreach 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 918900us
#### for 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 102200us
  • 第二次结果：
--------比较 for or foreach运行效率---------
#### foreach 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 631200us
#### for 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 104500us
  • 第三次结果：
--------比较 for or foreach运行效率---------
#### foreach 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 1672700us
#### for 运行结果 ---->>>>>
0	1	2	3	
10	11	12	13	
20	21	22	23	
程序运行时间： 608900us

End（总结）

经过上述一系列的试验，结果很明显了（虽然涉及了知识的盲区，但是还是瞎总结一番）

在 JVM 中存在某种机制（某种编译原理，尚未知悉），以致出现由编译顺序的不同导致编译时间的不同，即编译时间（运行时间）是受编译顺序的不同而不同。

如有知悉，还望指教。晚安！

人若无名，专心练剑！

java-基础-foreach与正常for循环效率对比
阿里Darker
07-29 6557
直接for循环效率最高，其次是迭代器和 ForEach操作。 作为语法糖，其实 ForEach 编译成 字节码之后，使用的是迭代器实现的，反编译后，testForEach方法如下： public static void testForEach(List list) { for (Iterator iterator = list.iterator(); iterator.hasNext
高薪程序员&面试题精讲系列18之for和foreach的区别、原理，哪个效率更高？
一一哥
11-15 2599
一. 面试题及剖析 1. 今日面试题 我们在刚开始学习Java基础知识的时候，很早就接触到了关于循环的内容，在面试时，面试官在这个地方也可能会问到一些面试题，比如： for和foreach有什么区别？ for与foreach循环的原理是什么样的？ 两者哪个效率更高？ 2. 题目剖析 上面这个题目主要是考察我们对Java中循环的操作和理解，这道题目本身没有太难的地方，题目的答案以记忆为主，没有太多需要理解的地方。 二. 参考答案 1. for与foreach的区别 1.1 语法不同
Java 中 for 和 foreach 哪个性能高？
java_beautiful的博客
06-30 1255
作为程序员每天除了写很多if else之外，写的最多的也包含for循环了，都知道我们Java中常用的for循环有两种方式，一种是使用for loop，另一种是使用foreach，那如果问你，这两种方式哪一种效率最高，你的回答是什么呢？ 首先我们先通过代码来实际测试一下，在计算耗时之前我们先创建一个大小集合，然后通过不断的获取集合中的内容来测试耗时。...
【017期】面试官问：Java 中 for、foreach、stream 哪个处理效率更高？
a1901149的博客
04-18 1262
对于面试，一定要有良好的心态，这位小伙伴面试美团的时候没有被前面阿里的面试影响到，发挥也很正常，也就能顺利拿下美团的offer。小编还整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家，也祝愿大家都能够升职加薪！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！8342936)][外链图片转存中…(img-BIE8jr6z-1713388342936)]也祝愿大家都能够升职加薪！
java的foreach遍历,JAVA for和foreach 遍历的效率
weixin_28950403的博客
03-11 647
for循环下标遍历 和 foreach 的原理比较(JAVA)今天看问答中又看到了类似的问题，就把自己理解过得写上来吧。去年看面试题也看到过，当时上网找没有搜到有说服力的。后来才弄明白并不是哪个一定好，是要分情况的。首先需要提到一个很重要的接口：RandomAccess 。里面没有任何实现(标记接口)，类似于序列化。作用在于：能够选择最优的算法来完成随机或者顺序读写。foreach的实现机制是利用...
1万条数据谁更快？Java循环性能大比拼：for、foreach、stream到底该怎么选？
最新发布
java专栏
09-24 860
摘要： Java遍历方式（for循环、foreach、Stream API）的性能差异显著：小数据量（<1万）时for循环最快，中等数据（10万）Stream串行表现提升，大数据（>100万）parallelStream并行优势明显。选择需结合场景：for循环适合精确控制和小数据，Stream适合链式操作和并行处理，foreach语法简洁但性能居中。优化时需注意数据量、线程安全及硬件影响，避免盲目使用高阶API。核心原则：根据需求选择最合适的遍历方式，而非一味追求代码简洁或新特性。
统计一篇超过10G的文章中每个单词出现的次数
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
02-27 171万+
本文介绍了一种基于分布式计算和多线程技术的方案，用于高效统计超大文本（如10GB以上）中每个单词的出现次数。文章首先讲解了如何将大文件切割成小文件，并将这些小文件分配到多台计算机上进行并行处理。每台计算机通过多线程统计本地文件的单词频率，并将结果合并到全局统计中。最终，统计结果可以存储到Redis等分布式存储系统中，以便快速查询。本文还讨论了性能优化的策略，如哈希算法的选择、并行计算的优化等，为大规模文本数据处理提供了有效的解决方案。
foreach和for两个循环的区别
03-26
另外，用户可能想知道在不同语言中的具体表现，比如C#的foreach，Python的for实际上是foreach，Java的增强for循环等。需要举例说明，让用户更明白语法差异。 最后，总结适用场景。当需要索引或者复杂控制时用for，...
Java中强制转换性能_【进阶之路】Java代码性能调优（一）
weixin_29890919的博客
02-25 1304
导言大家好，我是南橘，从接触java到现在也有差不多两年时间了，两年时间，从一名连java有几种数据结构都不懂超级小白，到现在懂了一点点的进阶小白，学到了不少的东西。知识越分享越值钱，我这段时间总结(包括从别的大佬那边学习，引用)了一些平常学习和面试中的重点(自我认为)，希望给大家带来一些帮助第一件事还是把思维导图贴给大家，因为用的是免费版，所以有水印，如果需要原始版本的话，可以加我的微信：一、字...
Java中高级面试题总览(一)
数据与算法架构提升之路专栏
03-29 2万+
高频面试题深入剖析
java for与forEach 效率
0与1的世界
07-24 343
jdk 6 package com.howtodoinjava.demo.core; import java.util.ArrayList; import java.util.Calendar; import java.util.List; public class ForLoopPerformanceTest { private static List&...
【17】面试官常问：Java 中 for、foreach、stream 哪个处理效率更高？
Java烂猪皮
05-25 4481
我们在开发中循环遍历一个数组经常会用到，jdk8推出了一些新特性，对循环做了比较，通过代码亲测，记录一下！
[Java] Java For Each 循环效率分析
架构探险之道
11-24 601
目录Java For Each 循环效率分析循环方式循环效率分析REFRENCES更多 Java For Each 循环效率分析 循环方式 for i for each while (iterator.hasNext()) {} / for( Iterator iterator = students.iterator();iterator.hasNext;){} students....
Java中for each与正常for循环效率对比
scuzoutao的博客
08-20 3890
循环ArrayList时，普通for循环比foreach循环花费的时间要少一点；循环LinkList时，普通for循环比foreach循环花费的时间要多很多。 当我将循环次数提升到一百万次的时候，循环ArrayList，普通for循环还是比foreach要快一点；但是普通for循环在循环LinkList时，程序直接卡死。结论：需要循环数组结构的数据时，建议使用普通for循环，因为for循环采用下标
python while循环和双重循环
张晨光老师的播客
08-17 9488
#python中，while语句用于循环执行程序，即在某个条件下，循环执行某段程序，以处理需要重复处理的相同任务。 #while是“当型”循环结构。 i=1 while i&lt;=20: print(i,end=" ") i+=1 sum=0 i=1 while i&lt;=100: sum+=i i+=1 else: print("\n",sum) ...
Java中for、foreach、stream区别和性能比较
刘皇叔说Java的博客
11-17 1万+
如果数据量在10万的时候，stream效率最高，其次是foreach,最后是for。另外需要注意的是如果数据达到100万的话，parallelStream异步并行处理效率最高，高于foreach和for。stream().forEach 和 forEach 方法都可以使用在集合类上，但是有一些区别。在效率方面，stream().forEach、forEach 和 parallelStream 之间存在一些差异。stream().forEach() 和 forEach() 在使用方式和行为上有一些区别。
Java 中for循环和foreach循环哪个更快？
_江屿_
01-18 828
Java 中for循环和foreach循环哪个更快？
java foreach效率_foreach与for效率问题
weixin_29053577的博客
02-20 1233
总结如下：1.如果只是遍历集合或者数组，用foreach好些，快些，因为for每遍历一次都要判断一下条件。2.如果对集合中的值进行修改，就要用for循环了。其实foreach的内部原理其实也是Iterator,但它不能像Iterator一样可以人为的控制，而且也不能调用iterator.remove()；更不能使用下标来访问每个元素，所以不能用于增加，删除等复杂的操作。--------------...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值