当前位置：首页 > 文章列表 > 文章 > java教程 > Java集合遍历四方法全解析

Java集合遍历四方法全解析

2025-08-12 17:53:43 0浏览收藏

Java集合遍历是编程中常见的操作，本文深入解析四种主流方法，助你高效处理数据。**增强for循环**简洁易用，适合只读遍历；**迭代器**则能在遍历时安全删除元素，避免并发问题；**传统for循环**凭借索引优势，方便访问List集合；而**Java 8 Stream API**则以函数式编程风格，简化复杂的数据处理流程，支持过滤、映射、排序等操作，甚至能进行并行计算。选择哪种遍历方式，需根据实际需求，权衡代码可读性与性能，找到最合适的解决方案。

遍历Java集合元素主要有以下几种方法：1. 增强for循环适用于只读遍历，代码简洁；2. 迭代器适用于遍历中需安全删除元素的场景；3. 传统for循环适用于需索引访问的List集合；4. Java 8 Stream API适用于复杂数据处理，支持函数式编程和并行操作。选择应根据具体需求如是否需修改集合、是否依赖索引或追求代码可读性而定，最终方案完整且有效。

java如何使用循环语句遍历集合元素 java循环遍历集合的详细教程

在Java里，遍历集合元素其实有那么几条路子可以走，每条路都有它自己的脾气和适用场景。简单来说，最常见也最直观的就是用增强for循环（也就是我们常说的for-each），它用起来特别顺手。如果需要更精细的控制，比如在遍历的时候删除元素，那迭代器（Iterator）就派上用场了。对于有索引的列表，传统的for循环也依然能打。当然，到了Java 8时代，Stream API又提供了一种更函数式、更简洁的遍历和操作方式。

解决方案

遍历Java集合元素，主要有以下几种常用且各有侧重的方法。选择哪种，往往取决于你的具体需求和对代码可读性的偏好。

1. 增强for循环 (For-each Loop) 这是最简洁、最常用的方式，特别适合只需要遍历集合元素而不需要知道其索引，也不需要在遍历过程中修改（删除）集合的情况。它隐藏了迭代器的复杂性，让代码看起来更干净。

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

public class CollectionIterationExample {
    public static void main(String[] args) {
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        System.out.println("--- 增强for循环 ---");
        for (String name : names) {
            System.out.println("你好, " + name);
        }
    }
}

2. 迭代器 (Iterator) 当你需要在遍历集合的同时，安全地删除某些元素时，迭代器是你的不二之选。增强for循环在底层其实也是通过迭代器实现的，但它没有暴露remove()方法，直接在增强for循环里尝试修改集合会抛出ConcurrentModificationException。

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

public class CollectionIterationExample {
    public static void main(String[] args) {
        List numbers = new ArrayList<>();
        numbers.add("One");
        numbers.add("Two");
        numbers.add("Three");
        numbers.add("Four");

        System.out.println("\n--- 迭代器循环 ---");
        Iterator it = numbers.iterator();
        while (it.hasNext()) {
            String num = it.next();
            System.out.println("当前元素: " + num);
            if ("Two".equals(num)) {
                it.remove(); // 安全删除元素
                System.out.println("删除了 'Two'");
            }
        }
        System.out.println("删除后的集合: " + numbers);
    }
}

3. 传统for循环 (Indexed For Loop) 这种方式主要适用于List接口的实现类（如ArrayList、Vector），因为它们支持通过索引来访问元素。当你需要根据元素的索引进行操作，或者需要反向遍历时，传统for循环会比较方便。

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

public class CollectionIterationExample {
    public static void main(String[] args) {
        List scores = new ArrayList<>();
        scores.add(90);
        scores.add(85);
        scores.add(92);

        System.out.println("\n--- 传统for循环 ---");
        for (int i = 0; i < scores.size(); i++) {
            System.out.println("索引 " + i + " 的分数: " + scores.get(i));
        }
    }
}

4. Java 8 Stream API Java 8引入的Stream API提供了一种更声明式、更函数式的处理集合数据的方式。它不仅可以遍历，还能进行过滤、映射、排序等一系列操作，链式调用让代码逻辑非常清晰，而且内部支持并行处理。

import java.util.Arrays;
import java.util.List;

public class CollectionIterationExample {
    public static void main(String[] args) {
        List cities = Arrays.asList("London", "Paris", "New York", "Tokyo");

        System.out.println("\n--- Java 8 Stream API ---");
        cities.stream()
              .filter(city -> city.startsWith("N")) // 过滤
              .map(String::toUpperCase)          // 转换
              .forEach(System.out::println);     // 遍历并打印
    }
}

迭代器和增强for循环，到底用哪个？

这问题挺有意思的，我个人觉得，这两种遍历方式就像是工具箱里的两把锤子，各有各的顺手之处。

增强for循环（for-each）无疑是现代Java开发者的首选，因为它写起来真的太舒服了，代码简洁明了，可读性极高。你不需要关心索引，也不用手动获取迭代器，直接for (ElementType element : collection)，就完事了。对于大多数只读遍历的场景，它简直是完美。比如，你只是想把列表里的名字都打印出来，或者计算一下所有数字的总和，用它准没错。它在底层其实就是个语法糖，编译器会把它转换成使用迭代器的形式。

但是，一旦你的需求稍微复杂一点，比如你需要在遍历集合的时候，根据某个条件把一些元素从集合里“踢出去”，这时候增强for循环就会让你头疼。如果你在for-each循环体里直接调用集合的remove()方法，恭喜你，你会遇到一个经典的ConcurrentModificationException。这是因为for-each循环在遍历时会检查集合的修改状态，一旦发现集合被“非法”修改（即不是通过迭代器自身的remove()方法修改），它就会抛出这个异常，防止你遇到一些意想不到的并发问题。

这时候，迭代器（Iterator）就显得不可替代了。它提供了一个remove()方法，允许你在遍历过程中安全地删除当前元素。当你需要边遍历边修改集合结构时，比如清理一个列表中的无效项，或者从一个集合中移除所有符合特定条件的元素，使用迭代器才是正确且安全的做法。虽然代码会比for-each稍微多写几行，但为了安全和功能，这点付出是值得的。

简单来说：

只读遍历、代码简洁至上：选增强for循环。
遍历时需要安全修改（删除）集合元素：选迭代器。

多线程环境下遍历集合，一不小心就踩坑？

确实，在多线程环境下操作集合，尤其是遍历，是个非常容易“踩坑”的地方。最常见的坑就是前面提到的ConcurrentModificationException，它不仅仅发生在单线程里for-each循环中修改集合，在多线程环境下，如果一个线程正在遍历集合，而另一个线程同时对集合进行了结构性修改（添加、删除元素），这个异常几乎是必然会发生的。这就像你正在看一本书，别人突然把书的几页撕掉了或者加了几页，你肯定会懵圈。

那么，怎么避免呢？

使用同步包装器（Synchronized Wrappers）：Java的Collections工具类提供了一些静态方法，可以将非线程安全的集合包装成线程安全的，比如Collections.synchronizedList()、Collections.synchronizedMap()。这些方法返回的集合，其所有方法（包括迭代）都会被同步，确保同一时间只有一个线程能访问集合。
```
List syncList = Collections.synchronizedList(new ArrayList<>());
// 在遍历时，你仍然需要手动同步迭代器，这常常被忽略
synchronized (syncList) {
    for (String item : syncList) {
        System.out.println(item);
    }
}
```
但这种方式有个隐患，就是虽然集合操作是同步的，但迭代器本身并不是。所以，即使你用了synchronizedList，在遍历时，你仍然需要手动对集合对象进行同步锁定，否则依然可能遇到ConcurrentModificationException。这有点反直觉，也容易出错。
使用并发集合类（Concurrent Collections）：这是Java并发包java.util.concurrent提供的解决方案，它们从设计之初就考虑了多线程环境下的性能和安全性。
- CopyOnWriteArrayList / CopyOnWriteArraySet: 它们在修改（添加、删除）时，会创建一个底层数组的副本，在新副本上进行修改，然后将引用指向新副本。这意味着读操作（包括遍历）是无锁的，非常快，因为它们总是操作一个不变的快照。缺点是写操作开销较大，且内存占用会增加。适合读多写少的场景。
```
import java.util.concurrent.CopyOnWriteArrayList;
List threadSafeList = new CopyOnWriteArrayList<>();
threadSafeList.add("A");
threadSafeList.add("B");
// 遍历时不需要额外同步，即使有其他线程在修改，也会看到遍历开始时的快照
for (String item : threadSafeList) {
    System.out.println(item);
}
```
- ConcurrentHashMap: 这是HashMap的线程安全版本，性能远超HashTable和Collections.synchronizedMap()。它通过分段锁（Java 7及以前）或CAS操作（Java 8）来提高并发度，读操作通常不需要加锁。
```
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;
Map concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key1", 1);
concurrentMap.put("key2", 2);
// 遍历时通常是弱一致性，即不保证看到所有最新的修改，但不会抛出ConcurrentModificationException
for (Map.Entry entry : concurrentMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
```
外部同步（External Synchronization）：如果你的集合不是并发集合，也没有通过Collections.synchronizedXxx()包装，那么最保险的办法就是在所有对集合的读写操作（包括遍历）外层都加上显式的同步锁。
```
List myList = new ArrayList<>();
// ...
// 所有访问 myList 的代码块都需要同步
synchronized (myList) {
    for (String item : myList) {
        System.out.println(item);
    }
}
```
这种方式虽然安全，但会显著降低并发性能，因为每次只有一个线程能访问集合。

选择哪种方式，取决于你的具体场景：如果读操作远多于写操作，CopyOnWriteArrayList是个不错的选择；如果需要高性能的并发Map，ConcurrentHashMap是标准答案；如果只是偶尔的并发访问，或者对性能要求不高，外部同步或synchronizedList可能也够用，但要特别注意迭代器的同步问题。

Java 8 Stream API：遍历集合的新姿势？

Java 8引入的Stream API，确实给集合的遍历和操作带来了“新姿势”，它不仅仅是遍历，更是一种声明式的数据处理管道。我个人觉得，它把我们从命令式的“怎么做”拉到了声明式的“做什么”，代码写起来更像是描述业务逻辑，而不是一步步地告诉机器执行什么指令。

Stream API的核心思想是，你可以把集合看作是一个数据流，然后在这个流上进行一系列的操作，这些操作可以分为两类：

中间操作（Intermediate Operations）：这些操作会返回一个新的Stream，它们是“懒惰的”，只有当终端操作被调用时才会真正执行。常见的有：
- filter(Predicate): 过滤元素，只保留符合条件的。
- map(Function): 将元素一对一地转换成另一种类型。
- flatMap(Function): 将元素一对多地转换，并把结果扁平化成一个Stream。
- sorted(): 对元素进行排序。
- distinct(): 去除重复元素。
- limit(long maxSize): 截断Stream，使其元素不超过给定数量。
- skip(long n): 跳过Stream的前n个元素。
终端操作（Terminal Operations）：这些操作会消费Stream，并产生一个最终结果或副作用，它们是触发中间操作执行的“开关”。常见的有：
- forEach(Consumer): 遍历Stream中的每个元素并执行指定操作（无返回值，有副作用）。
- collect(Collector): 将Stream中的元素收集到新的集合、Map或其他数据结构中。
- reduce(BinaryOperator): 将Stream中的元素聚合成一个单一结果。
- count(): 返回Stream中的元素数量。
- min(Comparator) / max(Comparator): 找到Stream中的最小/最大元素。
- anyMatch(Predicate) / allMatch(Predicate) / noneMatch(Predicate): 检查Stream中的元素是否匹配给定条件。
- findFirst() / findAny(): 找到Stream中的第一个/任意一个元素。

为什么说是“新姿势”？

链式调用，可读性强：你可以将多个操作像链条一样连接起来，形成一个清晰的数据处理管道。比如，从一个学生列表中，找出所有及格的女生，然后按分数排序，最后打印出她们的名字。

import java.util.Arrays;
import java.util.List;

class Student {
    String name;
    String gender;
    int score;

    public Student(String name, String gender, int score) {
        this.name = name;
        this.gender = gender;
        this.score = score;
    }

    public String getName() { return name; }
    public String getGender() { return gender; }
    public int getScore() { return score; }
}

public class StreamExample {
    public static void main(String[] args) {
        List students = Arrays.asList(
            new Student("张三", "男", 75),
            new Student("李四", "女", 90),
            new Student("王五", "男", 60),
            new Student("赵六", "女", 88)
        );

        students.stream()
                .filter(s -> s.getGender().equals("女")) // 筛选女生
                .filter(s -> s.getScore() >= 60)       // 筛选及格的
                .sorted((s1, s2) -> Integer.compare(s2.getScore(), s1.getScore())) // 按分数降序
                .map(Student::getName)                 // 提取名字
                .forEach(System.out::println);         // 遍历并打印
    }
}

这段代码的逻辑，一眼就能看明白它在做什么，比嵌套的for循环和if判断要清晰得多。

支持并行处理：Stream API可以轻松地转换为并行流（parallelStream()），利用多核CPU的优势进行并行计算，这对于处理大量数据时提升性能非常有帮助，而你几乎不需要关心并发编程的复杂性。

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream() // 转换为并行流
                 .filter(n -> n % 2 == 0) // 筛选偶数
                 .mapToInt(Integer::intValue) // 转换为IntStream
                 .sum(); // 求和
System.out.println("偶数和 (并行): " + sum);