用Java编写循环位移方阵，要可以控制移动方向和移动位数

好的，我可以为你提供一个简单的Java代码示例，用于实现循环位移方阵并可以控制移动方向和移动位数。以下是示例代码：

import java.util.Arrays;

public class MatrixShift {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 初始化一个 3x3 的方阵
        int direction = 1; // 移动方向，1 表示向右，2 表示向下，3 表示向左，4 表示向上
        int steps = 2; // 移动位数

        System.out.println("移动前的方阵：");
        printMatrix(matrix);

        shiftMatrix(matrix, direction, steps); // 调用移动方法

        System.out.println("移动后的方阵：");
        printMatrix(matrix);
    }

    public static void shiftMatrix(int[][] matrix, int direction, int steps) {
        int n = matrix.length; // 获取方阵的行数
        int[] temp; // 定义一个临时数组

        switch (direction) {
            case 1: // 向右移动
                for (int i = 0; i < n; i++) {
                    temp = Arrays.copyOf(matrix[i], n); // 复制当前行
                    for (int j = 0; j < n; j++) {
                        matrix[i][(j + steps) % n] = temp[j]; // 将当前行向右移动 steps 位
                    }
                }
                break;
            case 2: // 向下移动
                for (int j = 0; j < n; j++) {
                    temp = new int[n];
                    for (int i = 0; i < n; i++) {
                        temp[(i + steps) % n] = matrix[i][j]; // 将当前列向下移动 steps 位
                    }
                    matrix[0][j] = temp[0];
                    matrix[1][j] = temp[1];
                    matrix[2][j] = temp[2]; // 将移动后的列复制回原方阵
                }
                break;
            case 3: // 向左移动
                for (int i = 0; i < n; i++) {
                    temp = Arrays.copyOf(matrix[i], n);
                    for (int j = 0; j < n; j++) {
                        matrix[i][(j - steps + n) % n] = temp[j]; // 将当前行向左移动 steps 位
                    }
                }
                break;
            case 4: // 向上移动
                for (int j = 0; j < n; j++) {
                    temp = new int[n];
                    for (int i = 0; i < n; i++) {
                        temp[(i - steps + n) % n] = matrix[i][j]; // 将当前列向上移动 steps 位
                    }
                    matrix[0][j] = temp[0];
                    matrix[1][j] = temp[1];
                    matrix[2][j] = temp[2];
                }
                break;
            default:
                System.out.println("无效的移动方向！");
        }
    }

    public static void printMatrix(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

在上面的示例代码中，我们定义了一个 `shiftMatrix` 方法，用于实现方阵的循环位移。该方法接受三个参数，分别是要移动的方阵、移动方向和移动位数。其中，移动方向和移动位数由调用方法的代码传入。

在方法内部，我们使用了 `switch` 语句来根据移动方向的不同，分别进行方阵的移动操作。具体来说，向右移动时，我们使用了 `Arrays.copyOf` 方法来复制当前行，并将复制后的行向右移动 `steps` 位；向下移动时，我们则需要遍历每一列，并将当前列向下移动 `steps` 位；向左移动和向上移动的操作类似，只需要将向右移动和向下移动的代码进行适当的修改即可。

在调用 `shiftMatrix` 方法之后，我们还定义了一个 `printMatrix` 方法，用于输出移动前和移动后的方阵。该方法接受一个二维数组作为参数，遍历数组并依次输出每个元素的值。

希望这个示例代码可以帮助你实现循环位移方阵并可以控制移动方向和移动位数。