Java 典型数组操作算法

1、颠倒数组元素的顺序

/**
 * @Author ZhangGJ
 * @Date 2020/12/06 09:59
 */
public class ArrayReverseOrder {

    private static int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    /**
     * 颠倒数组元素的顺序
     *
     * @param original
     * @return
     */
    public static String reverseOrder(int[] original) {
        for (int i = 0; i < arr.length / 2; i++) {
            int data = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = data;
        }
        return Arrays.toString(arr);
    }

    public static void main(String[] args) {
        System.out.println(reverseOrder(arr));
    }
}

2、矩阵相乘

二维数组：

/**
 * 二维数组
 *
 * @Author ZhangGJ
 * @Date 2020/12/06 10:02
 */
public class ArrayTwoDimensional {

    public static int[][] twoDimensional(int row, int column) {
        int[][] a = new int[row][column];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                Random random = new Random();
                a[i][j] = random.nextInt(9);
                System.out.print(a[i][j]);
                if (j == 3) {
                    System.out.println();
                } else {
                    System.out.print(", ");
                }
            }
        }
        return a;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.deepToString(twoDimensional(3, 4)));
    }
}

Result:

8, 5, 6, 0
7, 5, 0, 4
3, 8, 0, 4
[[8, 5, 6, 0], [7, 5, 0, 4], [3, 8, 0, 4]]

矩阵相乘：
矩阵乘法中第一个矩阵的列要等于第二个矩阵的行。
第一个矩阵第一行的每个数字，各自乘以第二个矩阵第一列对应位置的数字，然后将乘积相加。

/**
 * @Author ZhangGJ
 * @Date 2020/12/06 10:18
 */
public class ArrayMatrixMultiplication {

    private static int[][] a, b;

    public static void initTwoDimensionalArray() {
        a = ArrayTwoDimensional.twoDimensional(2, 3);
        b = ArrayTwoDimensional.twoDimensional(3, 4);
    }

    public static int[][] matrixMultiplication() {
        initTwoDimensionalArray();
        int aLength = a.length;
        int[][] c = new int[aLength][aLength];
        for (int i = 0; i < aLength; i++) {
            for (int j = 0; j < aLength; j++) {
                for (int k = 0; k < aLength; k++) {
                    c[i][j] += a[i][k] * b[k][j];
                }
            }
        }
        return c;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.deepToString(matrixMultiplication()));
    }
}