方阵的顺时针旋转（JAVA）

题目描述：

输入一个N阶方阵(0<N<10)，输出此方阵顺时针旋转M(0<=M<=10000)次后的方阵

旋转举例：(如下四个三阶方阵从左到右为数字围绕中心顺时针旋转)

1 2 3 7 4 1 9 8 7 3 6 9

4 5 6 8 5 2 6 5 4 2 5 8

7 8 9 9 6 3 3 2 1 1 4 7

输入描述：

输入第一行一个正整数N(0<N<10)

接下来N行每行N个整数用空格分开，为方阵的数据

记下来一行一个正整数M(0<=M<=10000)

说明：不用考虑异常输入，所有输入都是正常的，严格遵从取值范围

输出描述：

N行，每行N个整数，用空格分开，为旋转后的数据

示例1：

输入：

1

1 2 3

4 5 6

7 8 9

2

输出：

9 8 7

6 5 4

3 2 1

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Solution {
    public static void main(String[] args) {
        new Solution().rotation();
    }

    public void rotation(){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println("N = " + n);
        int[][] origin = new int[n][n];
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            Scanner scanner1 = new Scanner(System.in);
            String data = scanner1.nextLine();
            String[] input = data.trim().split(" ");
            for (int j = 0; j < input.length; j++) {
                origin[i][j] = Integer.parseInt(input[j]);
            }
        }
        int time = 4;
        while (time-- != 0){
            int m = scanner.nextInt();
            System.out.println("M = " + m);
            int t = m % 4;
            switch (t){
                case 0 : {
                    printArr(origin,n);
                    break;
                }
                case 1 : {
                    for (int x = 0; x < n; x++) {
                        for (int y = n - 1; y >= 0; y--) {
                            result.add(origin[y][x]);
                        }
                        printArr(result);
                        result.clear();
                    }
                    break;

                }
                case 2 : {
                    for (int x = n - 1; x >= 0; x--) {
                        for (int y = n - 1; y >= 0; y--) {
                            result.add(origin[x][y]);
                        }
                        printArr(result);
                        result.clear();
                    }
                    break;
                }
                case 3 : {
                    for (int x = n - 1; x >= 0; x--) {
                        for (int y = 0; y < n; y++) {
                            result.add(origin[y][x]);
                        }
                        printArr(result);
                        result.clear();
                    }
                    break;
                }
                default:break;
            }
        }

    }

    public void printArr(int[][] arr, int n){
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j == n - 1){
                    System.out.println(arr[i][j]);
                }else {
                    System.out.print(arr[i][j] + " ");
                }
            }
        }
    }

    public void printArr(List<Integer> result){
        int n = result.size();
        for (int i = 0; i < n; i++) {
            if (i == n - 1){
                System.out.println(result.get(i));
            }else {
                System.out.print(result.get(i) + " ");
            }
        }
    }
}