https://chikuwa-tech-study.blogspot.com/2021/05/java-array-matrix.html

Matrix.java

public class Matrix {
    private int[][] data;

    public Matrix(int[][] data) {
        this.data = data;
    }

    public void add(Matrix matrix) {
        int[][] array = matrix.data;
        if (data.length != array.length || data[0].length != array[0].length) {
            throw new IllegalArgumentException();
        }

        for (int row = 0; row < data.length; row++) {
            for (int column = 0; column < data[row].length; column++) {
                data[row][column] += array[row][column];
            }
        }
    }

    public void multiply(Matrix matrix) {
        if (data[0].length != matrix.data.length) {
            throw new IllegalArgumentException();
        }

        int[][] result = new int[data.length][matrix.data[0].length];
        for (int row = 0; row < result.length; row++) {
            for (int column = 0; column < result[row].length; column++) {
                result[row][column] = calcWeightedValue(this, row, matrix, column);
            }
        }
        data = result;
    }

    private int calcWeightedValue(Matrix matrix1, int rowOfMatrix1, Matrix matrix2, int columnOfMatrix2) {
        int amountOfPair = matrix1.data[0].length;
        int result = 0;
        for (int i = 0; i < amountOfPair; i++) {
            result += matrix1.data[rowOfMatrix1][i] * matrix2.data[i][columnOfMatrix2];
        }

        return result;
    }

    public void transpose() {
        int[][] result = new int[data[0].length][data.length];
        for (int row = 0; row < data.length; row++) {
            for (int column = 0; column < data[row].length; column++) {
                result[column][row] = data[row][column];
            }
        }

        data = result;
    }

    public int[][] to3TupleTable() {
        int amountOfElement = data.length * data[0].length;
        Integer[] rowsOfNonZero = new Integer[amountOfElement];
        Integer[] columnsOfNonZero = new Integer[amountOfElement];
        int amountOfNonZero = 0;
        for (int row = 0; row < data.length; row++) {
            for (int column = 0; column < data[row].length; column++) {
                if (data[row][column] != 0) {
                    rowsOfNonZero[amountOfNonZero] = row;
                    columnsOfNonZero[amountOfNonZero] = column;
                    amountOfNonZero++;
                }
            }
        }

        int[][] table = new int[amountOfNonZero + 1][3];
        table[0][0] = data.length;
        table[0][1] = data[0].length;
        table[0][2] = amountOfNonZero;
        for (int i = 1; i <= amountOfNonZero; i++) {
            table[i][0] = rowsOfNonZero[i - 1];
            table[i][1] = columnsOfNonZero[i - 1];
            table[i][2] = data[table[i][0]][table[i][1]];
        }

        return table;
    }

    public static Matrix restoreFrom3TupleTable(int[][] table) {
        if (table.length < 1 || table[0].length != 3) {
            throw new IllegalArgumentException();
        }

        int[][] result = new int[table[0][0]][table[0][1]];
        for (int i = 1; i < table.length; i++) {
            int row = table[i][0];
            int column = table[i][1];
            result[row][column] = table[i][2];
        }

        return new Matrix(result);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int row = 0; row < data.length; row++) {
            for (int column = 0; column < data[row].length; column++) {
                sb.append(data[row][column]).append("\t");
            }
            sb.append("\n");
        }
        return sb.toString();
    }
}