用了那么久的 Java For 循环，你知道哪种方式效率最高吗？

忘是亡心i 2023-10-01 22:20 12阅读 0赞

作为程序员每天除了写很多 if else 之外，写的最多的也包含 for 循环了，都知道我们 Java 中常用的 for 循环有两种方式，一种是使用 for loop，另一种是使用 foreach，那如果问你，这两种方式哪一种效率最高，你的回答是什么呢？今天阿粉就来带你看一下。

首先我们先通过代码来实际测试一下，在计算耗时之前我们先创建一个大小集合，然后通过不断的获取集合中的内容来测试耗时。

package com.example.demo;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
 * 
 * Function： 
 * Author：@author ziyou 
 * Date：2022-06-26 12:22 
 * Desc：无 
 */
 public class ForTest {
 public static void main(String[] args) {
 
 //获取一个指定大小的 List 集合
 List<Integer> list = getList(1000000);
 
 // 开启 for loop 耗时计算
 long startFor = System.currentTimeMillis();
 for (int i = 0; i < list.size(); i++) {
 Integer integer = list.get(i);
 
 }
 long costFor = System.currentTimeMillis() - startFor;
 System.out.println("for loop cost for ArrayList：" + costFor);
 
 // forEach 耗时计算
 long forEachStartTime = System.currentTimeMillis();
 for (Integer integer : list) {
 }
 long forEachCost = System.currentTimeMillis() - forEachStartTime;
 System.out.println("foreach cost for ArrayList：" + forEachCost);
 
 }
 
 public static List<Integer> getList(int size) {
 List<Integer> list = new ArrayList<>();
 for (int i = 0; i < size; i++) {
 list.add(i);
 }
 return list;
 }
 
 }

简单说明一下上面的带，先创建一个 List ，然后通过两种方式的遍历来计算耗时，根据集合的大小不同，我们进行运行会得到下面的一些测试数据，不同人的机器上面运行的时间会不一定，不过差距应该也不会太大。

通过上面的测试结果我们可以发现，在集合相对较小的情况下，for loop 和 foreach 两者的耗时基本上没有什么差别，当集合的数据量相对较大的时候，可以明显看的出来，for loop 的效率要比 foreach 的效率高。

至于为什么在大数据量的情况下 forEach 的效率要比 for 低，我们就要看下 forEach 的原理了。forEach 其实不是一种新的语法，而是一种 Java 的语法糖。在编译时，编译器会将这段代码转换成迭代器实现，并编译成字节码，我们可以再简单的看个 case，来实际看下字节码信息。

我们再编写一个简单的类，代码如下：

通过 javac ForEachTest.java 编译成 class 文件，再通过 javap -v ForEachTest 反编译，我们就会得到下面的字节码内容：

Classfile /Users/silence/Downloads/demo/src/test/java/com/example/demo/ForEachTest.class
 Last modified 2022-6-26; size 643 bytes
 MD5 checksum 9cf01f7c8c87c2b4d62c39d437025b7f
 Compiled from "ForEachTest.java"
 public class com.example.demo.ForEachTest
 minor version: 0
 major version: 52
 flags: ACC_PUBLIC, ACC_SUPER
 Constant pool:
 #1 = Methodref #8.#23 // java/lang/Object."<init>":()V
 #2 = Fieldref #7.#24 // com/example/demo/ForEachTest.list:Ljava/util/List;
 #3 = InterfaceMethodref #25.#26 // java/util/List.iterator:()Ljava/util/Iterator;
 #4 = InterfaceMethodref #27.#28 // java/util/Iterator.hasNext:()Z
 #5 = InterfaceMethodref #27.#29 // java/util/Iterator.next:()Ljava/lang/Object;
 #6 = Class #30 // java/lang/Integer
 #7 = Class #31 // com/example/demo/ForEachTest
 #8 = Class #32 // java/lang/Object
 #9 = Utf8 list
 #10 = Utf8 Ljava/util/List;
 #11 = Utf8 Signature
 #12 = Utf8 Ljava/util/List<Ljava/lang/Integer;>;
 #13 = Utf8 <init>
 #14 = Utf8 ()V
 #15 = Utf8 Code
 #16 = Utf8 LineNumberTable
 #17 = Utf8 main
 #18 = Utf8 ([Ljava/lang/String;)V
 #19 = Utf8 StackMapTable
 #20 = Class #33 // java/util/Iterator
 #21 = Utf8 SourceFile
 #22 = Utf8 ForEachTest.java
 #23 = NameAndType #13:#14 // "<init>":()V
 #24 = NameAndType #9:#10 // list:Ljava/util/List;
 #25 = Class #34 // java/util/List
 #26 = NameAndType #35:#36 // iterator:()Ljava/util/Iterator;
 #27 = Class #33 // java/util/Iterator
 #28 = NameAndType #37:#38 // hasNext:()Z
 #29 = NameAndType #39:#40 // next:()Ljava/lang/Object;
 #30 = Utf8 java/lang/Integer
 #31 = Utf8 com/example/demo/ForEachTest
 #32 = Utf8 java/lang/Object
 #33 = Utf8 java/util/Iterator
 #34 = Utf8 java/util/List
 #35 = Utf8 iterator
 #36 = Utf8 ()Ljava/util/Iterator;
 #37 = Utf8 hasNext
 #38 = Utf8 ()Z
 #39 = Utf8 next
 #40 = Utf8 ()Ljava/lang/Object;
 {
 java.util.List<java.lang.Integer> list;
 descriptor: Ljava/util/List;
 flags:
 Signature: #12 // Ljava/util/List<Ljava/lang/Integer;>;
 
 public com.example.demo.ForEachTest();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=1, locals=1, args_size=1
 0: aload_0
 1: invokespecial #1 // Method java/lang/Object."<init>":()V
 4: return
 LineNumberTable:
 line 13: 0
 
 public void main(java.lang.String[]);
 descriptor: ([Ljava/lang/String;)V
 flags: ACC_PUBLIC
 Code:
 stack=1, locals=4, args_size=2
 0: aload_0
 1: getfield #2 // Field list:Ljava/util/List;
 4: invokeinterface #3, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
 9: astore_2
 10: aload_2
 11: invokeinterface #4, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
 16: ifeq 32
 19: aload_2
 20: invokeinterface #5, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
 25: checkcast #6 // class java/lang/Integer
 28: astore_3
 29: goto 10
 32: return
 LineNumberTable:
 line 17: 0
 line 19: 29
 line 20: 32
 StackMapTable: number_of_entries = 2
 frame_type = 252 /* append */
 offset_delta = 10
 locals = [ class java/util/Iterator ]
 frame_type = 250 /* chop */
 offset_delta = 21
 }
 SourceFile: "ForEachTest.java"

反编译的内容很多，不一一解释，可以看到这个字节码的一般含义是使用 getfield 命令获取变量，并调用 List.iterator 获取迭代器实例再调用 iterator.hasNext，如果返回 true，则调用 iterator.next 方法，这是迭代器遍历集合的实现逻辑。

写到这里有小伙伴就要问了，那以后遇到 List 集合我就用 for loop 了，不用 foreach了，毕竟前者的效率更好。那么接下来我们再看一个 case，这里我们把 ArrayList 换成 LinkedList，代码如下：

public static List<Integer> getList(int size) {
 List<Integer> list = new LinkedList<>();
 for (int i = 0; i < size; i++) {
 list.add(i);
 }
 return list;
 }

从上面的数据可以很明显的看到，当在处理 LinkedList 的时候，for loop 明显就慢很多了。相信具体的原因大家也知道，ArrayList 底层是基于数组结构的，所以使用 for loop 操作起来会很快，时间复杂度是 O(1)，但是 LinkedList 底层是链表结构，此时如果在想通过索引来操作数据，时间复杂度将是 O (n\*n)。

所以具体使用哪种循环方式以及具体需要使用哪种数据结构，都需要根据实际的业务情况来选择，任何一种方案的存在都是合理的，你小伙你们认为呢？

![32016f091662463f9864365d87b6ad7c.jpeg][]

[32016f091662463f9864365d87b6ad7c.jpeg]: https://img-blog.csdnimg.cn/32016f091662463f9864365d87b6ad7c.jpeg