Java 2D 数组：高效查找每行最大/最小值教程

在处理二维数组时，一个常见的需求是找出整个数组中的最大值和最小值。然而，在某些场景下，我们需要更细粒度的分析，例如找出每一行独立的最大值和最小值。这要求我们在每次处理新行时，都能“重置”我们的统计逻辑。

理解问题：为何简单修改整体查找代码行不通？

考虑以下代码片段，它用于查找整个二维数组的全局最大值和最小值：

public class Main {

    public static void main(String[] args) {
        int[][] data = {
            {3, 2, 5},
            {1, 4, 4, 8, 13},
            {9, 1, 0, 2},
            {0, 2, 6, 3, -1, -8}
        };

        int max = data[0][0]; // 初始化为第一个元素
        int min = data[0][0]; // 初始化为第一个元素

        for (int row = 0; row < data.length; row++) {
            for (int col = 0; col < data[row].length; col++) {
                if (data[row][col] > max) {
                    max = data[row][col];
                }
                if (data[row][col] < min) {
                    min = data[row][col];
                }
            }
        }
        System.out.println("整体最大值 = " + max + "; 整体最小值 = " + min);
    }
}

这段代码能够正确地找出整个 data 数组的最大值和最小值。问题在于，如果只是简单地将 System.out.println 语句移动到外层循环（即每处理完一行就打印），max 和 min 变量并不会为新的一行而重置。它们会持续累积之前行的最大/最小值，导致输出结果并非当前行的独立统计。例如，如果第一行的最大值是5，第二行的最大值是4，那么在处理第二行时，max 变量仍然会是5，而不是第二行独立的4。

核心解决方案：每行独立初始化与处理

解决这个问题的关键在于：在开始处理每一行之前，必须将用于存储当前行最大/最小值的变量重置为合适的初始值。

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

1. 初始化策略

为了确保能够正确捕获当前行的所有可能值（包括非常小或非常大的数），最佳实践是将当前行的最大值初始化为 Integer.MIN_VALUE，将最小值初始化为 Integer.MAX_VALUE。这样，数组中的任何第一个元素都将立即更新这些初始值。

2. 循环结构与变量作用域

我们需要一个外层循环来遍历每一行，并在外层循环内部、内层循环（遍历列）开始之前，声明并初始化用于当前行的 max 和 min 变量。

3. 代码实现

以下是实现这一逻辑的完整 Java 代码示例：

办公小浣熊

办公小浣熊是基于商汤大语言模型的原生数据分析产品，

77

查看详情

public class ArrayRowStatistics {

    public static void main(String[] args) {
        int[][] data = {
            {3, 2, 5},
            {1, 4, 4, 8, 13},
            {9, 1, 0, 2},
            {0, 2, 6, 3, -1, -8} // 包含负数的行
        };

        System.out.println("--- 查找每行的最大值和最小值 ---");

        for (int row = 0; row < data.length; row++) {
            // 检查当前行是否为空。空行没有最大/最小值。
            if (data[row].length == 0) {
                System.out.println("行 " + row + ": 为空，无最大值或最小值。");
                continue; // 跳过当前空行，处理下一行
            }

            // 为当前行初始化最大值和最小值
            // 必须在外层循环内部，确保每处理一行都重置
            int currentRowMax = Integer.MIN_VALUE; // 初始化为Java int类型的最小值
            int currentRowMin = Integer.MAX_VALUE; // 初始化为Java int类型的最大值

            // 遍历当前行的所有元素
            for (int col = 0; col < data[row].length; col++) {
                int currentValue = data[row][col];

                if (currentValue > currentRowMax) {
                    currentRowMax = currentValue;
                }
                if (currentValue < currentRowMin) {
                    currentRowMin = currentValue;
                }
            }

            // 打印当前行的结果
            System.out.println("行 " + row + ": 最大值 = " + currentRowMax + "; 最小值 = " + currentRowMin);
        }
    }
}

示例输出：

--- 查找每行的最大值和最小值 ---
行 0: 最大值 = 5; 最小值 = 2
行 1: 最大值 = 13; 最小值 = 1
行 2: 最大值 = 9; 最小值 = 0
行 3: 最大值 = 6; 最小值 = -8

代码解析：

1. for (int row = 0; row < data.length; row++): 这是外层循环，负责遍历二维数组的每一行。
2. if (data[row].length == 0): 这是一个重要的健壮性检查。如果某一行是空的（即 data[row] 是一个空数组），那么它就没有元素可以比较，也就没有最大值或最小值。我们在此处进行检查并跳过，避免后续对空行进行无效的统计。
3. int currentRowMax = Integer.MIN_VALUE; 和 int currentRowMin = Integer.MAX_VALUE;: 这两个变量是实现按行统计的关键。它们被声明在外层循环内部，这意味着每次进入一个新的行（row）的迭代时，它们都会被重新初始化。Integer.MIN_VALUE 是 int 类型能够表示的最小数值，而 Integer.MAX_VALUE 则是最大数值。这样初始化可以确保数组中的任何实际元素（无论是正数、负数还是零）都能正确地更新这两个变量。
4. for (int col = 0; col < data[row].length; col++): 这是内层循环，负责遍历当前行 (data[row]) 中的所有元素。
5. 比较逻辑: if (currentValue > currentRowMax) 和 if (currentValue < currentRowMin) 负责在当前行内更新最大值和最小值。
6. System.out.println(...): 在内层循环结束后（即当前行所有元素都已遍历完毕），打印出该行的 currentRowMax 和 currentRowMin。由于这些变量在每行开始时都已重置，因此打印的是当前行的独立统计结果。

注意事项

• 空行处理： 上述代码已包含了对空行的处理。在实际应用中，如果二维数组可能包含空行，这一检查是必不可少的。

• 数据类型： 示例中使用的是 int 类型。如果处理 long, float, double 等其他数值类型，应相应地使用 Long.MIN_VALUE/MAX_VALUE, Float.MIN_VALUE/MAX_VALUE, Double.MIN_VALUE/MAX_VALUE 或 Double.NEGATIVE_INFINITY/POSITIVE_INFINITY 进行初始化。

• 存储结果： 如果不仅仅是打印，而是需要将每行的最大/最小值用于后续处理，可以将它们存储在一个新的数据结构中，例如 ArrayList<int[]> 或 Map<Integer, int[]>：

  import java.util.ArrayList;
  import java.util.List;
  
  // ... 在 main 方法中 ...
  List<int[]> rowStatsList = new ArrayList<>(); // 存储每行的 [最大值, 最小值]
  
  for (int row = 0; row < data.length; row++) {
      // ... (同上，计算 currentRowMax 和 currentRowMin) ...
  
      if (data[row].length > 0) {
          rowStatsList.add(new int[]{currentRowMax, currentRowMin});
          System.out.println("行 " + row + ": 最大值 = " + currentRowMax + "; 最小值 = " + currentRowMin);
      } else {
          // 可以选择添加一个特殊标记或不添加，取决于需求
          // rowStatsList.add(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE}); // 例如，用特殊值表示空行
          System.out.println("行 " + row + ": 为空，无最大值或最小值。");
      }
  }
  // 之后可以遍历 rowStatsList 来访问每行的统计数据
  // for (int[] stats : rowStatsList) {
  //     System.out.println("统计结果: 最大值=" + stats[0] + ", 最小值=" + stats[1]);
  // }

  登录后复制

• 与整体最大最小值的结合： 如果在查找每行最大/最小值的同时，也需要找出整个数组的全局最大/最小值，可以在外层循环之外维护一对全局变量，并在每次计算完 currentRowMax 和 currentRowMin 后，用它们来更新全局变量。

总结

在 Java 中查找二维数组每行的最大/最小值，关键在于理解变量的作用域和初始化时机。通过在外层循环（遍历行）内部，内层循环（遍历列）开始之前，为每行独立地初始化最大值和最小值变量，并利用 Integer.MIN_VALUE 和 Integer.MAX_VALUE 进行安全的初始赋值，我们可以确保对每一行的数据进行准确且独立的统计。这种模式不仅适用于查找最大/最小值，也适用于其他需要按维度进行独立聚合计算的场景。

以上就是Java 2D 数组：高效查找每行最大/最小值教程的详细内容，更多请关注php中文网其它相关文章！