Java ArrayList中存储对象数组的引用陷阱与深拷贝解决方案

public class Matrices {
    private int M[][]; // 按照Java命名规范，通常建议使用小写字母m

    public int[][] getM() {
        return M;
    }

    public void setM(int[][] M) {
        this.M = M;
    }
}

import java.util.ArrayList;

public class FloydAlgorithmExample {

    // 假设panel.CreaMatriz() 和 panel.EscribeMatrices() 是外部方法
    // 简化示例，此处用模拟数据代替
    static class Panel {
        public int[][] CreaMatriz() {
            // 模拟初始矩阵
            return new int[][]{
                {0, 3, 1, Integer.MAX_VALUE},
                {Integer.MAX_VALUE, 0, Integer.MAX_VALUE, Integer.MAX_VALUE},
                {Integer.MAX_VALUE, 4, 0, 1},
                {3, Integer.MAX_VALUE, Integer.MAX_VALUE, 0}
            };
        }

        public String EscribeMatrices(int[][] matrix) {
            StringBuilder sb = new StringBuilder();
            for (int[] row : matrix) {
                for (int val : row) {
                    if (val == Integer.MAX_VALUE) {
                        sb.append(" ∞ ");
                    } else {
                        sb.append(String.format("%3d", val));
                    }
                }
                sb.append("\n");
            }
            return sb.toString();
        }
    }

    public static void main(String[] args) {
        Panel panel = new Panel();
        ArrayList<Matrices> matrices = new ArrayList<>();

        // 初始矩阵
        int[][] A = panel.CreaMatriz();

        // 模拟节点数量
        ArrayList<Object> nodos = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            nodos.add(new Object()); // 模拟有4个节点
        }

        // Floyd算法的迭代过程
        for (int k = 0; k < nodos.size(); k++) {
            // 每次迭代都创建一个新的Matrices对象
            Matrices m = new Matrices();
            // 将当前A的引用赋给m
            m.setM(A); 
            matrices.add(m); // 添加到ArrayList中

            // 在这里A被修改，例如执行Floyd算法的中间步骤
            for (int i = 0; i < nodos.size(); i++) {
                for (int j = 0; j < nodos.size(); j++) {
                    if (A[i][k] != Integer.MAX_VALUE && A[k][j] != Integer.MAX_VALUE &&
                        A[i][k] + A[k][j] < A[i][j]) {
                        A[i][j] = A[i][k] + A[k][j];
                    }
                }
            }
        }

        // 打印所有保存的矩阵
        System.out.println("期望保存的矩阵数量: " + nodos.size());
        System.out.println("实际ArrayList中的矩阵数量: " + matrices.size());
        for (int i = 0; i < matrices.size(); i++) {
            System.out.println("\n--- 迭代 " + i + " 后的矩阵 ---");
            System.out.println(panel.EscribeMatrices(matrices.get(i).getM()));
        }
    }
}

public class ArrayUtils {
    /**
     * 对二维整型数组进行深拷贝。
     * @param original 原始二维数组
     * @return 原始数组的一个独立副本
     */
    public static int[][] deepCopy(int[][] original) {
        if (original == null) {
            return null;
        }
        int[][] copy = new int[original.length][];
        for (int i = 0; i < original.length; i++) {
            if (original[i] != null) {
                // 使用 Arrays.copyOf 复制内层一维数组
                copy[i] = java.util.Arrays.copyOf(original[i], original[i].length);
            } else {
                copy[i] = null; // 处理内层数组为null的情况
            }
        }
        return copy;
    }
}

import java.util.ArrayList;
import java.util.Arrays; // 用于Arrays.copyOf

// ... (Matrices类和Panel类保持不变，或根据Java命名规范进行修改) ...

public class FloydAlgorithmCorrectedExample {

    // ... (Panel类定义，同上) ...

    // 辅助类，用于深拷贝数组
    static class ArrayUtils {
        public static int[][] deepCopy(int[][] original) {
            if (original == null) {
                return null;
            }
            int[][] copy = new int[original.length][];
            for (int i = 0; i < original.length; i++) {
                if (original[i] != null) {
                    copy[i] = Arrays.copyOf(original[i], original[i].length);
                } else {
                    copy[i] = null;
                }
            }
            return copy;
        }
    }

    public static void main(String[] args) {
        Panel panel = new Panel();
        ArrayList<Matrices> matrices = new ArrayList<>();

        int[][] A = panel.CreaMatriz();

        ArrayList<Object> nodos = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            nodos.add(new Object());
        }

        for (int k = 0; k < nodos.size(); k++) {
            Matrices m = new Matrices();
            // 关键：在设置矩阵前，对当前A数组进行深拷贝
            m.setM(ArrayUtils.deepCopy(A)); 
            matrices.add(m);

            // Floyd算法的中间计算，会修改A
            for (int i = 0; i < nodos.size(); i++) {
                for (int j = 0; j < nodos.size(); j++) {
                    if (A[i][k] != Integer.MAX_VALUE && A[k][j] != Integer.MAX_VALUE &&
                        A[i][k] + A[k][j] < A[i][j]) {
                        A[i][j] = A[i][k] + A[k][j];
                    }
                }
            }
        }

        // 打印所有保存的矩阵，现在应该显示不同的状态
        System.out.println("期望保存的矩阵数量: " + nodos.size());
        System.out.println("实际ArrayList中的矩阵数量: " + matrices.size());
        for (int i = 0; i < matrices.size(); i++) {
            System.out.println("\n--- 迭代 " + i + " 后的矩阵 ---");
            System.out.println(panel.EscribeMatrices(matrices.get(i).getM()));
        }
    }
}