首页 > 文章 > java教程

Java数组遍历方法及实例解析

时间：2025-08-02 15:23:36 144浏览收藏

本文深入解析了Java数组的三种主要遍历方法，并结合实例进行了详细讲解。针对不同场景，选择合适的遍历方式至关重要。传统的`for`循环提供了索引访问的强大控制力，适用于需要修改元素或进行复杂逻辑控制的场景；增强型`for-each`循环则以其简洁的语法和高可读性，成为只读遍历的首选；而Java 8引入的Stream API，凭借其函数式编程风格和并行处理能力，尤其擅长处理大数据和复杂的链式操作。文章还总结了遍历数组时常见的索引越界、空指针等陷阱，并探讨了各种遍历方式的效率差异。此外，文章还介绍了利用`Arrays`工具类和Stream API进行数组批量初始化、转换、查找、过滤和聚合等高级应用场景，帮助读者更高效地处理Java数组。

在Java中遍历数组主要有三种方式：传统for循环、增强型for循环（for-each）和Java 8的Stream API。1. 传统for循环提供最大的控制灵活性，允许通过索引访问和修改元素，支持逆序、跳跃等复杂遍历逻辑；2. 增强型for循环语法简洁、可读性高，适用于仅需读取元素而无需索引的场景，但无法直接修改数组内容；3. Stream API提供函数式编程风格，支持过滤、映射、归约等复杂操作，并可并行处理大数据，适合需要链式操作和复杂数据处理的场景。选择方式应根据具体需求决定：需要索引或修改元素时用传统for循环，简单遍历时优先使用for-each，处理复杂逻辑或大数据时选择Stream API。此外，遍历数组时需注意索引越界、空指针异常、数组长度固定等常见陷阱。

如何在Java中遍历数组 Java数组遍历技巧和示例

在Java中遍历数组，主要有三种方式：传统的for循环、简洁的增强型for循环（也称作for-each循环），以及Java 8引入的Stream API。每种方式都有其适用场景和特点，选择哪种取决于你的具体需求和偏好。

解决方案

要遍历Java数组，最直接也是最常用的方法就是利用循环结构来访问数组中的每一个元素。

1. 传统for循环

这是最基础也最灵活的方式。通过一个索引变量从0开始递增，直到数组长度减一，依次访问每个位置的元素。这种方式的强大之处在于，你不仅能读取元素，还能根据索引修改元素，或者进行逆序遍历、跳跃遍历等更复杂的控制。

public class ArrayTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};

        // 传统for循环遍历
        System.out.println("--- 传统for循环遍历 ---");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("元素在索引 " + i + " 处: " + numbers[i]);
            // 举个例子，如果我想修改偶数索引的元素：
            // if (i % 2 == 0) {
            //     numbers[i] = numbers[i] * 2;
            // }
        }

        // 也可以倒序遍历，这种灵活性是for-each不具备的
        System.out.println("\n--- 传统for循环倒序遍历 ---");
        for (int i = numbers.length - 1; i >= 0; i--) {
            System.out.println("倒序元素: " + numbers[i]);
        }
    }
}

我个人觉得，虽然for-each现在用得更多，但for循环的这种“掌控感”是无可替代的，特别是在需要精确控制迭代过程时，比如跳过某些元素，或者同时处理两个相关联的数组（通过同一个索引）。

2. 增强型for循环（for-each循环）

如果你只是想简单地遍历数组中的所有元素，而不需要关心它们的索引，那么for-each循环是你的首选。它语法简洁，代码可读性高，大大减少了出错的可能性（比如数组越界）。

public class ArrayTraversalExample {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry"};

        // 增强型for循环遍历
        System.out.println("\n--- 增强型for循环遍历 ---");
        for (String fruit : fruits) {
            System.out.println("水果: " + fruit);
            // 注意：这里不能直接修改fruit变量来改变数组元素，因为fruit只是一个副本
            // 如果需要修改，你还是得回到传统for循环或者使用Stream API
        }
    }
}

很多时候，我发现自己写代码时，脑子里第一个想到的就是for-each，因为它确实太方便了。对于大多数只读的遍历场景，它简直是完美。

3. Java 8 Stream API

Java 8引入的Stream API为集合和数组的处理提供了更现代、函数式编程风格的方式。它不仅可以遍历，还能进行过滤、映射、归约等一系列复杂操作，并且支持并行处理，对于大数据量的处理尤其强大。

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

public class ArrayTraversalExample {
    public static void main(String[] args) {
        Double[] prices = {19.99, 25.50, 12.00, 30.75};

        // 使用Stream API遍历并打印
        System.out.println("\n--- Stream API 遍历 (forEach) ---");
        Arrays.stream(prices)
              .forEach(price -> System.out.println("价格: " + price));

        // Stream API 的其他强大功能：过滤、映射等
        System.out.println("\n--- Stream API 过滤并映射 ---");
        List highPrices = Arrays.stream(prices)
                                        .filter(p -> p > 20.00) // 过滤出大于20的价格
                                        .map(p -> p * 0.9)     // 所有高价打九折
                                        .collect(Collectors.toList()); // 收集成List
        System.out.println("打折后的高价商品: " + highPrices);

        // 如果是基本数据类型数组，可以使用对应的IntStream, LongStream, DoubleStream
        int[] intNumbers = {1, 2, 3, 4, 5};
        System.out.println("\n--- IntStream 遍历并求和 ---");
        int sum = Arrays.stream(intNumbers)
                        .sum(); // 直接求和
        System.out.println("数组元素之和: " + sum);
    }
}

刚开始接触Stream API的时候，觉得有点绕，但一旦习惯了它的链式调用和函数式思维，你会发现它处理复杂逻辑时简直是神器，代码变得异常简洁和富有表达力。尤其是在处理集合数据时，它的优势更加明显。

Java数组遍历时常见的陷阱有哪些？

在Java中遍历数组，虽然看起来简单，但确实存在一些容易踩的坑，特别是对于新手。最经典的莫过于IndexOutOfBoundsException。当你使用传统的for循环时，如果循环条件写错了，比如把i < numbers.length写成了i <= numbers.length，那么在最后一次迭代时，你就会尝试访问一个不存在的索引（numbers.length），导致程序崩溃。这几乎是我刚学Java时遇到的第一个运行时错误，印象深刻。

另一个常见问题是，如果你在遍历过程中尝试修改数组的长度（比如你把数组当成了列表，想动态增删元素），这在Java数组中是不可能的，因为数组一旦创建，长度就固定了。这种思维上的混淆有时会导致设计上的错误。虽然Java数组本身不支持动态扩容，但如果你在遍历一个集合（比如ArrayList）时同时修改它，就会遇到ConcurrentModificationException。对于数组来说，虽然没有这个异常，但逻辑上可能会出现你意想不到的行为，比如你修改了当前迭代的元素，但这个修改是否影响后续迭代，取决于你的逻辑。

还有，对于包含对象的数组，要特别注意空指针（NullPointerException）。如果数组中的某个位置是null，而你又直接尝试调用这个null元素的某个方法，那恭喜你，又一个经典错误出现了。所以，在访问数组元素之前，尤其是对象数组，进行null检查是一个好习惯。

String[] names = new String[3];
names[0] = "Alice";
names[2] = "Charlie"; // names[1] 默认是 null

for (String name : names) {
    // 危险！如果 name 是 null，这里会抛出 NullPointerException
    // System.out.println(name.toUpperCase()); 

    // 正确的做法是先检查
    if (name != null) {
        System.out.println(name.toUpperCase());
    } else {
        System.out.println("发现一个空名字");
    }
}

总的来说，理解数组的固定大小特性、索引的范围以及空引用的可能性，是避免这些陷阱的关键。

选择哪种遍历方式更高效？

关于效率，这是一个常被问起的话题，但答案往往是“看情况”。对于大多数现代Java虚拟机（JVM）来说，在处理小型到中等规模的数组时，传统for循环和增强型for循环的性能差异几乎可以忽略不计。JVM的即时编译器（JIT）非常智能，它会把for-each循环优化成接近甚至等同于传统for循环的字节码。所以，如果你只是简单地遍历并读取数组元素，选择for-each，因为它更简洁、更安全。

但如果你的需求更复杂，比如：

需要访问索引： 传统for循环是唯一直接提供索引的方式。
需要修改数组元素： 传统for循环是直接且高效的选择。
需要进行复杂的链式操作（过滤、映射、归约等）或并行处理： Java 8 Stream API无疑是最佳选择。虽然Stream API在启动时会有一定的开销（因为它构建了管道），但在处理大量数据且可以并行化时，它的性能优势会非常明显。对于小数据集，Stream的开销可能会让它比简单循环慢一点点，但这通常不构成性能瓶颈。

我个人的经验是，除非你正在处理亿万级别的数据，或者在一个对毫秒级响应时间有严苛要求的系统中，否则没必要过度纠结于for循环和for-each的微小性能差异。可读性和代码的简洁性往往更重要。而Stream API，它的价值更多体现在表达能力和处理复杂业务逻辑时的优雅。当你发现自己写了一堆嵌套循环和条件判断来处理数据时，不妨想想Stream API是否能让代码更清晰。

除了基本遍历，还有哪些高级应用场景？

除了简单的打印或访问元素，Java数组的遍历还可以延伸到许多高级应用场景，尤其结合java.util.Arrays工具类和Stream API，能玩出不少花样。

数组元素的批量初始化或转换： 如果你想根据某个规则初始化或转换数组中的所有元素，Arrays.setAll()和Arrays.parallelSetAll()方法就派上用场了。它们接受一个函数式接口作为参数，可以为数组的每个索引位置计算一个值。parallelSetAll在处理大数组时，可以利用多核CPU并行计算，显著提升性能。

import java.util.Arrays;

public class AdvancedArrayTraversal {
    public static void main(String[] args) {
        int[] arr = new int[10];
        // 使用Arrays.setAll初始化数组，每个元素是其索引的平方
        Arrays.setAll(arr, i -> i * i);
        System.out.println("初始化后的数组: " + Arrays.toString(arr)); // 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

        String[] names = {"alice", "bob", "charlie"};
        // 将所有名字转换为大写
        Arrays.setAll(names, i -> names[i].toUpperCase());
        System.out.println("转换为大写的名字: " + Arrays.toString(names)); // 输出: [ALICE, BOB, CHARLIE]
    }
}

这比手动写一个for循环来逐个赋值要简洁得多，也更符合函数式编程的风格。

查找、过滤与聚合操作： Stream API在数组上的高级应用主要体现在数据处理管道上。你可以轻松地进行：

查找： findFirst(), findAny(), anyMatch(), allMatch(), noneMatch()
过滤： filter()
映射（转换）： map(), flatMap()
排序： sorted()
去重： distinct()
聚合： reduce(), sum(), average(), count(), min(), max()

import java.util.Arrays;
import java.util.OptionalDouble;

public class AdvancedArrayTraversal {
    public static void main(String[] args) {
        double[] temperatures = {25.3, 28.1, 22.5, 30.0, 27.8};

        // 找出高于27度的温度的平均值
        OptionalDouble averageHighTemp = Arrays.stream(temperatures)
                                               .filter(t -> t > 27.0) // 过滤出高温
                                               .average();             // 计算平均值
        averageHighTemp.ifPresent(avg -> System.out.println("高于27度的平均温度: " + avg));

        // 检查是否有温度达到30度
        boolean hasHighTemp = Arrays.stream(temperatures)
                                    .anyMatch(t -> t >= 30.0);
        System.out.println("是否有温度达到30度: " + hasHighTemp);
    }
}

这些操作让数组的处理变得异常强大和灵活，尤其是当数据量大，或者需要复杂的数据转换时，Stream API的优势就体现出来了。它将“做什么”和“怎么做”分离，让代码意图更清晰。

并行处理大数据： 对于非常大的数组，如果你的操作是独立的（即一个元素的处理不依赖于其他元素的处理），那么使用Stream API的parallel()方法可以充分利用多核CPU进行并行处理，大幅提升性能。

import java.util.Arrays;

public class AdvancedArrayTraversal {
    public static void main(String[] args) {
        int[] largeArray = new int[1_000_000];
        // 假设这里填充了大量数据
        for (int i = 0; i < largeArray.length; i++) {
            largeArray[i] = i % 100; // 简单填充
        }

        long startTime = System.nanoTime();
        long sumSerial = Arrays.stream(largeArray).sum();
        long endTime = System.nanoTime();
        System.out.println("串行求和: " + sumSerial + ", 耗时: " + (endTime - startTime) / 1_000_000.0 + " ms");

        startTime = System.nanoTime();
        long sumParallel = Arrays.stream(largeArray).parallel().sum(); // 启用并行流
        endTime = System.nanoTime();
        System.out.println("并行求和: " + sumParallel + ", 耗时: " + (endTime - startTime) / 1_000_000.0 + " ms");
    }
}

在实际运行中，你会发现并行流在处理这种计算密集型任务时，确实能带来显著的性能提升。当然，并行流并非万能药，它也有自己的适用场景和开销，并非所有任务都适合并行化。但对于数组这种连续内存结构，它通常表现不错。

这些高级用法，在我看来，才是真正体现Java在处理数据方面的现代性和强大之处。它们让代码更具表达力，也更易于维护和扩展。

理论要掌握，实操不能落！以上关于《Java数组遍历方法及实例解析》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！