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

遍历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<String> 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<String> numbers = new ArrayList<>();
        numbers.add("One");
        numbers.add("Two");
        numbers.add("Three");
        numbers.add("Four");

        System.out.println("\n--- 迭代器循环 ---");
        Iterator<String> 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<Integer> 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<String> 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循环，到底用哪个？

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

立即学习“Java免费学习笔记（深入）”；

增强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<String> 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<String> 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<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key1", 1);
concurrentMap.put("key2", 2);
// 遍历时通常是弱一致性，即不保证看到所有最新的修改，但不会抛出ConcurrentModificationException
for (Map.Entry<String, Integer> entry : concurrentMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

登录后复制

外部同步（External Synchronization）：如果你的集合不是并发集合，也没有通过
```
Collections.synchronizedXxx()
```
登录后复制
包装，那么最保险的办法就是在所有对集合的读写操作（包括遍历）外层都加上显式的同步锁。
```
List<String> 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<Student> 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<Integer> 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);

登录后复制