image.png

AC代码

import java.util.*;
class Solution {
    private List<Integer> curArr;
    private List<Integer> nextArr;
    public void rotate(int[][] matrix) {
        if(matrix == null || matrix.length == 0) {
            return;
        }
        curArr = new ArrayList<>();
        nextArr = new ArrayList<>();
        //change
        for(int step = 0; step < matrix.length / 2; step++) {
            int k = step;
            for(int i = step; i < matrix.length - step - 1; i++) {
                curArr.add(matrix[step][k]);
                k++;
            }
            for(int i = 0; i < 4; i++) {
                change(matrix, i, step);
            }
            curArr.clear();
        }
    }
    private void change(int[][] matrix, int status, int step) {
        int n = matrix.length - 1;
        int start = step;
        int end = n - step;
        switch(status) {
            case 0:{
                for(int i = start, k = 0; i <= end - 1 && k < curArr.size(); i++, k++) {
                    nextArr.add(matrix[i][end]);
                    matrix[i][end] = curArr.get(k);
                }
                break;
            }
            case 1:{
                for(int i = end, k = 0; i >= start + 1 && k < curArr.size(); i--, k++) {
                    nextArr.add(matrix[end][i]);
                    matrix[end][i] = curArr.get(k);
                }
                break;
            }
            case 2:{
                for(int i = end, k = 0; i >= start + 1 && k < curArr.size(); i--, k++) {
                    nextArr.add(matrix[i][start]);
                    matrix[i][start] = curArr.get(k);
                }
                break;
            }
            case 3:{
                for(int i = start, k = 0; i <= end - 1 && k <= curArr.size(); i++, k++) {
                    matrix[start][i] = curArr.get(k);
                }
                break;
            }

        }
        curArr = new ArrayList<>(nextArr);
        nextArr.clear();
    }
}

精髓
一圈套一圈，每一圈的旋转逻辑是一样的，逐渐往里缩。
还有更为巧妙的方法：先求转置，然后左右镜像对称，这个一时想不到