Java foreach 遍历 List：深入解析与最佳实践

简介

在 Java 编程中，遍历集合是一项常见的操作。foreach 循环作为一种简洁且强大的语法糖，为遍历 List 等集合提供了便利。本文将深入探讨 Java 中使用 foreach 循环遍历 List 的相关知识，包括基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一重要的编程技巧。

基础概念

foreach 循环，也称为增强 for 循环，是 Java 5 引入的一种语法糖，用于更方便地遍历数组和实现了 Iterable 接口的集合类，如 List。它简化了传统 for 循环遍历集合的代码结构，使代码更加简洁、易读。

使用方法

基本语法

foreach 循环的基本语法如下：

for (元素类型 元素变量 : 集合对象) {
    // 执行的代码块
}

其中，元素类型 是集合中元素的类型，元素变量 是一个临时变量，用于存储每次迭代从集合中取出的元素，集合对象 是要遍历的 List 或其他可迭代对象。

遍历不同类型的 List

下面以 ArrayList 为例，展示如何使用 foreach 循环遍历不同类型的 List。

遍历 Integer 类型的 List

import java.util.ArrayList;
import java.util.List;

public class ForeachListExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        for (Integer number : numbers) {
            System.out.println(number);
        }
    }
}

遍历自定义对象类型的 List

假设我们有一个自定义类 Person：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

遍历 Person 类型的 List：

import java.util.ArrayList;
import java.util.List;

public class ForeachCustomListExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));

        for (Person person : people) {
            System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
        }
    }
}

常见实践

读取 List 元素

foreach 循环最常见的用途之一是读取 List 中的元素。例如，我们有一个存储字符串的 List，想要打印出每个字符串：

import java.util.ArrayList;
import java.util.List;

public class ReadListElements {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Apple");
        names.add("Banana");
        names.add("Cherry");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

对 List 元素进行操作

除了读取元素，我们还可以对 List 中的元素进行各种操作。例如，计算 List 中所有整数的总和：

import java.util.ArrayList;
import java.util.List;

public class OperateOnListElements {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        int sum = 0;
        for (Integer number : numbers) {
            sum += number;
        }
        System.out.println("Sum: " + sum);
    }
}

结合条件判断

在遍历 List 时，我们常常需要结合条件判断来处理特定的元素。例如，找出 List 中所有大于 10 的整数：

import java.util.ArrayList;
import java.util.List;

public class ConditionalTraversal {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(15);
        numbers.add(20);

        for (Integer number : numbers) {
            if (number > 10) {
                System.out.println(number);
            }
        }
    }
}

最佳实践

避免在 foreach 中修改 List

在 foreach 循环中直接修改 List 的结构（如添加或删除元素）会导致 ConcurrentModificationException。这是因为 foreach 循环基于集合的迭代器实现，在迭代过程中修改集合结构会使迭代器状态失效。

如果需要在遍历过程中修改 List，可以使用传统的 for 循环，或者使用迭代器的 remove 方法。例如：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ModifyListSafely {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        // 使用迭代器删除元素
        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            Integer number = iterator.next();
            if (number % 2 == 0) {
                iterator.remove();
            }
        }
        System.out.println(numbers);
    }
}

性能考量

在性能方面，foreach 循环对于大多数情况已经足够高效。但对于非常大的 List，如果需要频繁随机访问元素，传统的 for 循环使用索引访问可能会更高效，因为 foreach 循环本质上是基于迭代器的顺序访问。

与 Stream API 结合使用

Java 8 引入的 Stream API 为集合操作提供了更强大和灵活的方式。foreach 循环可以与 Stream API 结合使用，实现更复杂的操作，如过滤、映射、归约等。例如：

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamAndForeach {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        // 使用 Stream API 过滤并打印偶数
        numbers.stream()
              .filter(number -> number % 2 == 0)
              .forEach(System.out::println);

        // 使用 Stream API 对元素进行映射并收集到新的 List
        List<Integer> squaredNumbers = numbers.stream()
                                              .map(number -> number * number)
                                              .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

小结

本文详细介绍了 Java 中使用 foreach 循环遍历 List 的相关知识，包括基础概念、使用方法、常见实践以及最佳实践。foreach 循环为遍历 List 提供了简洁、易读的方式，但在使用过程中需要注意避免在循环中修改 List 结构，同时根据具体场景考虑性能问题，并结合 Stream API 实现更强大的功能。希望通过本文的学习，读者能够更好地掌握和运用 foreach 循环遍历 List，提高 Java 编程效率。