用java代码实现矩阵的各种相关运算

用java代码实现二维矩阵相乘、二维矩阵相加、矩阵求逆、计算矩阵的行列式、矩阵的伴随矩阵、矩阵求转置、三维矩阵相乘、三维矩阵相加：

//两个二维矩阵相乘
    public static int[][] multiply(int[][] A, int[][] B) {
        int[][] C = new int[A.length][B[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B[0].length; j++) {
                for (int k = 0; k < A[0].length; k++) {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }
    //两个二维矩阵相加
    public static int[][] add(int[][] A, int[][] B) {
        int[][] C = new int[A.length][B[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B[0].length; j++) {
                C[i][j] = A[i][j] + B[i][j];
            }
        }
        return C;
    }
    //两个二维矩阵相减
    public static int[][] subtract(int[][] A, int[][] B) {
        int[][] C = new int[A.length][B[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B[0].length; j++) {
                C[i][j] = A[i][j] - B[i][j];
            }
        }
        return C;
    }
    //获取矩阵的逆
    public static int[][] inverse(int[][] A) {
        int[][] B = new int[A.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                B[i][j] = A[i][j];
            }
        }
        int[][] C = new int[A.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                C[i][j] = (int) Math.pow(-1, i + j) * determinant(minor(B, j, i));
            }
        }
        int[][] D = new int[A.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                D[i][j] = C[i][j] / determinant(A);
            }
        }
        return D;
    }
    //求解矩阵的行列式
    private static int determinant(int[][] a) {
        if (a.length == 1) {
            return a[0][0];
        }
        int det = 0;
        for (int i = 0; i < a[0].length; i++) {
            det += (int) Math.pow(-1, i) * a[0][i] * determinant(minor(a, 0, i));
        }
        return det;
    }
    //求解二维矩阵在某一位置的伴随矩阵
    private static int[][] minor(int[][] b, int i, int j) {
        int[][] a = new int[b.length - 1][b[0].length - 1];
        for (int x = 0, y = 0; x < b.length; x++) {
            if (x == i) {
                continue;
            }
            for (int m = 0,n = 0; m < b[0].length; m++) {
                if (m == j) {
                    continue;
                }
                a[y][n] = b[x][m];
                n++;
            }
            y++;
        }
        return a;
    }

    //二维矩阵求转置
    public static int[][] transpose(int[][] A) {
        int[][] B = new int[A[0].length][A.length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < A[0].length; j++) {
                B[j][i] = A[i][j];
            }
        }
        return B;
    }
    //两个三维矩阵相乘
    public static int[][][] multiply(int[][][] A, int[][][] B) {
        int[][][] C = new int[A.length][B.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                for (int k = 0; k < A[0].length; k++) {
                    for (int l = 0; l < B[0].length; l++) {
                        C[i][j][k] += A[i][j][k] * B[j][k][l];
                    }
                }
            }
        }
        return C;
    }
    //两个三维矩阵相加
    public static int[][][] add(int[][][] A, int[][][] B) {
        int[][][] C = new int[A.length][B.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                for (int k = 0; k < A[0].length; k++) {
                    C[i][j][k] = A[i][j][k] + B[i][j][k];
                }
            }
        }
        return C;
    }
    //两个三维矩阵相减
    public static int[][][] subtract(int[][][] A, int[][][] B) {
        int[][][] C = new int[A.length][B.length][A[0].length];
        for (int i = 0; i < A.length; i++) {
            for (int j = 0; j < B.length; j++) {
                for (int k = 0; k < A[0].length; k++) {
                    C[i][j][k] = A[i][j][k] - B[i][j][k];
                }
            }
        }
        return C;
    }