Java矩阵行列求和问题：无法正确获取最小行和的解决方案咨询

嘿，我一眼就揪出问题所在啦！你遇到的这个bug，核心是Java数组的引用类型特性在搞鬼～

问题根源 #

你代码里的tempRows和smallRows都是数组对象，而Java里数组是引用类型——当你执行smallRows = tempRows;的时候，并不是把tempRows里的元素复制给smallRows，而是让smallRows和tempRows指向同一个内存地址的数组。

所以每次循环时，你把当前行的元素赋值给tempRows，其实是修改了这个共享数组的内容；循环到最后一行时，这个数组里装的就是最后一行的元素，自然smallRows的和就是最后一行的和了。

修复方案 #

这里有两种思路，一种是修复原代码的引用问题，另一种是优化逻辑让代码更简洁高效：

方案1：修复引用赋值问题

把直接赋值数组引用的操作，改成复制数组的内容，可以用Arrays.copyOf()或者System.arraycopy()来实现：

import java.util.Arrays;
import java.util.Random;

public class MatrixSum {
    public static void main(String[] args) {
        int rows = 4;
        int columns = 5;
        int[][] matrix = new int[rows][columns];
        Random random = new Random(); // 把Random实例放在外面，避免重复创建
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                matrix[i][j] = random.nextInt(9) + 1;
            }
        }
        printMatrix(matrix);
        
        int[] smallRows = new int[columns];
        for (int i = 0; i < rows; i++) {
            int[] tempRows = matrix[i]; // 直接用当前行数组，不用手动赋值一遍
            int currentSum = sum(tempRows);
            int smallSum = sum(smallRows);
            
            if(smallSum == 0) {
                // 复制数组内容，而非引用
                smallRows = Arrays.copyOf(tempRows, tempRows.length);
            } else if (currentSum < smallSum) {
                smallRows = Arrays.copyOf(tempRows, tempRows.length);
            }
        }
        
        System.out.println("最小行和的行：" + Arrays.toString(smallRows));
        System.out.println("最小行和：" + sum(smallRows));
    }

    public static int sum(int[] a) {
        int sum = 0;
        for (int num : a) {
            sum += num;
        }
        return sum;
    }

    public static void printMatrix(int mat[][]) {
        for (int[] row : mat) {
            System.out.println(Arrays.toString(row));
        }
    }
}

方案2：优化逻辑，避免不必要的数组复制

其实你根本不需要保存tempRows这个中间数组，也不用每次复制smallRows——直接记录最小行和以及对应的行就好，这样代码更高效：

import java.util.Arrays;
import java.util.Random;

public class MatrixSum {
    public static void main(String[] args) {
        int rows = 4;
        int columns = 5;
        int[][] matrix = new int[rows][columns];
        Random random = new Random();
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                matrix[i][j] = random.nextInt(9) + 1;
            }
        }
        printMatrix(matrix);
        
        int minRowSum = Integer.MAX_VALUE;
        int[] minRow = null;
        
        for (int i = 0; i < rows; i++) {
            int currentSum = sum(matrix[i]);
            if (currentSum < minRowSum) {
                minRowSum = currentSum;
                minRow = Arrays.copyOf(matrix[i], matrix[i].length);
            }
        }
        
        System.out.println("最小行和的行：" + Arrays.toString(minRow));
        System.out.println("最小行和：" + minRowSum);
    }

    public static int sum(int[] a) {
        int sum = 0;
        for (int num : a) {
            sum += num;
        }
        return sum;
    }

    public static void printMatrix(int mat[][]) {
        for (int[] row : mat) {
            System.out.println(Arrays.toString(row));
        }
    }
}

额外提示 #

• 原代码里每次循环都new Random()不太高效，建议把Random对象放在循环外面，避免重复创建实例。
• 计算列和的逻辑可以用类似的思路：遍历列索引，累加每列的元素即可，同样要注意避免引用类问题。

内容的提问来源于stack exchange，提问作者mastaresplinter