这是kotlin的解决方案！

fun displayMatrix(matrix: Array<IntArray>) {
    for(row in matrix) {
        for(column in row) {
            print("$column  ")
        }
        println()
    }
}

fun main() {

//Create Array
val matrixA = arrayOf(intArrayOf(2, 3, 4), intArrayOf(5, 6, 4), intArrayOf(1, 6, 7), intArrayOf(0, 2, 8))

println("Dimension on X: ${matrixA[0].size}")
println("Dimension on Y: ${matrixA.size}")

displayMatrix(matrixA)

println()

val transposeMatrix = Array(matrixA[0].size) { IntArray(matrixA.size) }

for(i in 0..matrixA.size - 1) {
    for(j in 0..matrixA[0].size - 1) {
        transposeMatrix[j][i] = matrixA[i][j]
    }
}

displayMatrix(transposeMatrix)

}

这是一个简单的方法，返回转置矩阵的int[][]。。。

public static int[][] transposeMatrix(int[][] matrix){
    int m = matrix.length;
    int n = matrix[0].length;

    int[][] transposedMatrix = new int[n][m];

    for(int x = 0; x < n; x++) {
        for(int y = 0; y < m; y++) {
            transposedMatrix[x][y] = matrix[y][x];
        }
    }

    return transposedMatrix;
}

要打印二维矩阵，您可以使用以下方法：

public static String matrixToString(int[][] a){
    int m = a.length;
    int n = a[0].length;

    String tmp = "";
    for(int y = 0; y<m; y++){
        for(int x = 0; x<n; x++){
            tmp = tmp + a[y][x] + " ";
        }
        tmp = tmp + "\n";
    }

    return tmp;
}

以上提供的答案在记忆方面并不有效。它使用的是另一个数组-transposedmatrix，而不是作为参数提供的数组。这将导致消耗双倍内存。我们可以按如下方式进行：

public void transposeMatrix(int[][] a)
{
        int temp;
        for(int i=0 ; i<(a.length/2 + 1); i++)
        {
            for(int j=i ; j<(a[0].length) ; j++)
            {
                temp = a[i][j];
                a[i][j] = a[j][i];
                a[j][i] = temp;
            }
        }

        displayMatrix(a);
    }

public void displayMatrix(int[][] a){
        for(int i=0 ; i<a.length ; i++)
        {
            for(int j=0 ; j<a[0].length ; j++)
            {
                System.out.print(a[i][j] + " ");
            }

            System.out.println();
        }
    }

你可以使用下面的类，它有你想要的大多数方法。

/**
 * Class representing square matrix of given size.
 * It has methods to rotate by 90, 180 and 270
 * And also to transpose and flip on either axis.
 * 
 * I have used both space efficient methods in transpose and flip
 * And simple but more space usage for rotation. 
 * 
 * This is using builder pattern hence, you can keep on applying
 * methods say rotate90().rotate90() to get 180 turn.
 * 
 */
public class Matrix {

    private int[][] matrix;
    final int size;

    public Matrix(final int size) {
        this.size = size;
        matrix = new int[size][size];

        for (int i=0;i<size;i++)
            for (int j=0;j<size;j++)
                matrix[i][j] = i*size + j;
    }

    public Matrix rotate90() {
        int[][] temp = new int[size][size];

        for (int i=0;i<size;i++)
            for (int j=0;j<size;j++)
                temp[i][j] = matrix[size-1-j][i];

        matrix = temp;
        return this;
    }
    public Matrix rotate180() {
        int[][] temp = new int[size][size];

        for (int i=0;i<size;i++)
            for (int j=0;j<size;j++)
                temp[i][j] = matrix[size-1-i][size-1-j];

        matrix = temp;
        return this;
    }
    public Matrix rotate270() {
        int[][] temp = new int[size][size];

        for (int i=0;i<size;i++)
            for (int j=0;j<size;j++)
                temp[i][j] = matrix[j][size-1-i];

        matrix = temp;
        return this;
    }
    public Matrix transpose() {
        for (int i=0; i<size-1; i++) {
            for (int j=i+1; j<size; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = tmp;
            }
        }
        return this;
    }
    public Matrix flipVertical() {
        for (int i=0; i<size; i++) {
            for (int j=0; j<size/2; j++) {
                int tmp = matrix[i][size-1-j];
                matrix[i][size-1-j] = matrix[i][j];
                matrix[i][j] = tmp;
            }
        }
        return this;
    }
    public Matrix flipHorizontal() {
        for (int i=0; i<size/2; i++) {
            for (int j=0; j<size; j++) {
                int tmp = matrix[size-1-i][j];
                matrix[size-1-i][j] = matrix[i][j];
                matrix[i][j] = tmp;
            }
        }
        return this;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<size;i++) {
            for (int j=0;j<size;j++) {
                sb.append("|");
                sb.append(matrix[i][j]);
                if (size > 3) {
                    sb.append("\t");
                }
            }
            sb.append("|\n");
        }

        return sb.toString();
    }

    public static void main(String... args) {
        Matrix m = new Matrix(3);
        System.out.println(m);

        //transpose and flipHorizontal is 270 turn (-90)
        System.out.println(m.transpose());
        System.out.println(m.flipHorizontal());

        //rotate 90 further to bring it back to original position
        System.out.println(m.rotate90());

        //transpose and flip Vertical is 90 degree turn
        System.out.println(m.transpose().flipVertical());
    }
}

输出：

|0|1|2|
|3|4|5|
|6|7|8|

|0|3|6|
|1|4|7|
|2|5|8|

|2|5|8|
|1|4|7|
|0|3|6|

|0|1|2|
|3|4|5|
|6|7|8|

|6|3|0|
|7|4|1|
|8|5|2|

对于一个方阵，您只需遍历2d数组的对角部分，并用相应的索引交换值，而不是遍历整个数组。

public void transposeMatrix(int[][] a) {
        for(int i=0 ; i<n; i++) { 
            for(int j=0 ; j<i ; j++) {
                int temp = a[i][j];
                a[i][j] = a[j][i];
                a[j][i] = temp;
            }
        }
}