Java循环对比：传统for循环、增强型for循环和forEach循环

以你之姓@ 2023-10-16 15:08 79阅读 0赞

## **1****、传统for循环** ##

传统的for循环是一种经典的循环结构，在Java中广泛使用。

以下是传统for循环的特点：

灵活控制：传统for循环使用形式为for (初始化表达式; 终止条件; 步进表达式)的语法，可以手动控制循环的索引，并根据需要执行自定义操作。

索引访问：传统for循环通过索引访问集合或数组中的元素，可以直接读取和修改元素的值。

例如：

import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    
            for (int i = 0; i < numbers.size(); i++) {
                System.out.println(numbers.get(i));  // 读取元素的属性值或执行操作是允许的
                numbers.set(i, 10);  // 直接修改元素的值是允许的
            }
        }
    }

底层操作：相比增强型for循环，传统for循环提供了更底层的操作，更加灵活，但也更加繁琐。

适用对象：适用于任何实现了Iterable或Iterator接口的集合类。

示例代码：

public class Demo {
        public static void main(String[] args) {
            int[] numbers = {1, 2, 3, 4, 5};
            for (int i = 0; i < numbers.length; i++) {
                System.out.println(numbers[i]);
            }
        }
    }

传统for循环代码结构是这样的：

for(循环变量的初始声明;循环的判定条件;改变循环变量的条件)\{

循环体

其中执行顺序是:①循环变量的初始声明(声明循环变量) ②循环的判断条件(判定是否继续执行循环，是boolean值) ③循环体(想要重复执行的代码段) ④改变循环变量的条件(用于结束循环) ⑤再回到2中判断是否跳出循环，如果判断结果是true，继续上述过程。如果判断结果是false，则跳出整个循环代码段，执行后续代码。

如测试通过遍历方式,实现为数组赋值,赋值为100,200,300,400,500

import java.util.Arrays;
    
    public class Demo {
        public static void main(String[] args) {
            int[] arr = new int[5];
            int num = 100;
            for (int i = 0; i < arr.length; i++) {
                arr[i] = num;
                num += 100;
            }
            System.out.println(Arrays.toString(arr));
        }
    }

代码的输出结果是这样的：\[100, 200, 300, 400, 500\]

显而易见，普通for循环通过下标索引，将值赋值到了数组内部。

## **2****、增强型****for****循环** ##

增强型for循环，也称为foreach循环，是一种简化版的循环语法。它可以用于遍历数组或实现了Iterable接口的集合类。

以下是增强型for循环的特点：

语法简洁：增强型for循环使用形式为for (元素类型 元素变量 : 集合或数组)的语法，使代码更易读和编写。

只读访问：在每次迭代中，增强型for循环提供对当前元素的只读访问权限，不能直接修改元素的值。

例如：

import java.util.ArrayList;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("Hello");
            list.add("World");
            System.out.println(list);
            for (String s : list) {
                s = "New Value";  // 尝试修改元素的值
            }
            System.out.println(list);
        }
    }

适用对象：适用于数组或实现了Iterable接口的集合类。

示例代码：

import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("Apple", "Banana", "Orange");
            for (String fruit : list) {
                System.out.println(fruit);
            }
        }
    }

增强型for循环代码结构是这样的:

for(接收数组元素的类型 变量名:数组)\{

变量名代表数组中的每一个数据

增强for可以遍历数组中的每一个元素，用前面的变量名来接收。我强调一下是接收，因为类型所定义的变量只是用来接收数组中各个元素，而不是将每个元素分离出来。

列如上面问题，测试通过2种遍历方式,分别实现为数组赋值,赋值为100,200,300,400,500

import java.util.Arrays;
    
    public class Demo {
        public static void main(String[] args) {
            int[] arr = new int[5];
            int num = 100;
            for (int i : arr) {
                i = num;
                num += 100;
            }
            System.out.println(Arrays.toString(arr));
        }
    }

代码输出结果是这样的：\[0, 0, 0, 0, 0\]

也就是说增强for循环根本没有将值传到数组内部。这也是普通for与增强for的区别，普通for循环可以实现为数组赋值，根据索引操作；foreach只能遍历获取，不能修改数组中的数据。

除此之外，:前面是接收数组元素的类型，这里强调的是，这里定义的类型是接受数组元素的类型，不必是数组的类型关系。

for(long|float|double|.. i:arr){
    	i=num;
    	num+=100；
    }

其实类型没有那么严格，只要是能接收这个int型的数组arr的元素即可。当然不能接收的其他类型，比如byte，short ，char…就会报错。

## **3****、****forEach****循环** ##

forEach是Java 8中引入的一个方法，用于遍历集合中的元素并对其执行某种操作。它可以接受一个函数作为参数，这个函数会对集合中的每个元素进行操作。这个函数可以是Lambda表达式，也可以是一个普通的函数接口。

Lambda表达式在Java 8中被引入，是一种简洁，函数式的方法来编写某些操作。Lambda表达式主要被用于创建只有一个方法的接口，这个接口可以包含一个参数列表和一个表达式或一个块语句。这种表达式或块语句就是Lambda体。

以下是Lambda表达式for循环的特点：

函数式风格：Lambda表达式for循环采用函数式编程风格，通过Lambda表达式定义循环体的操作，使代码更加简洁和易读。

自动迭代：与增强型for循环类似，Lambda表达式for循环自动迭代集合或数组中的元素，无需手动控制索引。

例如：

import java.util.Arrays;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
            // 使用Java 8的forEach和Lambda表达式
            list.forEach(fruit -> System.out.println(fruit));
        }
    }

## **4****、效率简单对比** ##

说明:测试可能有不严谨的地方,时间,机器,执行顺序,cpu运行后效率降低也有可能,仅供参考

import java.util.ArrayList;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            long[] numbers = {10000L, 100000L, 1000000L, 10000000L};
            for (int j= 0; j < numbers.length; j++) {
                long times = numbers[j];
                System.out.println("操作次数:" + times);
                List<String> list = new ArrayList<>();
                List<String> list1 = new ArrayList<>();
                List<String> list2 = new ArrayList<>();
                List<String> list3 = new ArrayList<>();
                for (int i = 0; i < times; i++) {
                    list.add(new String());
                }
                long startTime = System.currentTimeMillis();
                //普通for
                for (int i = 0; i < list.size(); i++) {
                    list1.add(list.get(i));
                }
                long endTime = System.currentTimeMillis();
                System.out.println("普通for时间(毫秒):" + (endTime - startTime));
                //增强for
                long startTime1 = System.currentTimeMillis();
                for (String s : list) {
                    list2.add(s);
                }
                long endTime1 = System.currentTimeMillis();
                System.out.println("增强for时间(毫秒):" + (endTime1 - startTime1));
    
                long startTime2 = System.currentTimeMillis();
                //forEach
                list.forEach(s -> list3.add(s));
                long endTime2 = System.currentTimeMillis();
                System.out.println("forEach时间(毫秒):" + (endTime2 - startTime2));
            }
        }
    }

执行结果：

操作次数:10000

普通for时间(毫秒):1

增强for时间(毫秒):1

forEach时间(毫秒):59

操作次数:100000

普通for时间(毫秒):2

增强for时间(毫秒):2

forEach时间(毫秒):3

操作次数:1000000

普通for时间(毫秒):37

增强for时间(毫秒):10