Java 从字符串数组打印矩阵

我有一个字符串二维数组，我需要把它格式化成一个矩阵。我需要的是这样的东西：

   1  3  4
-124 52  6

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

  2   3   4   5
  7   8   9  10
-12 -11 -10  -9

我必须考虑矩阵中最长的一行，所以矩阵中的其他行与它对齐。我已经编写了代码来确定哪一行最长，因为它将基于这一点，但我不知道格式化它的确切方式

这是我在将整数矩阵转换为字符串矩阵时确定最长行长度的代码：

String[][]解决方案=新字符串[m][n]；
int l=0；
对于（int j=0；j

因此，假设您的数组存储为array[r][c]。因此，您要做的是检查列和行。简单地说，你能做的是：

如果（c>r）{构建一个嵌套循环，其中行是外部循环}

如果r>c，则执行相反的操作。希望这有助于

我假设“看起来像一个矩阵”，你指的是矩阵元素之间的等距间距

这是我想到的

    1    3    4
 -124   52    6

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

   2   3   4   5
   7   8   9  10
 -12 -11 -10  -9

“诀窍”是找到打印字符数最多的元素，并使用该长度加上1来获得行上单元格之间的间距

String

类有一个

format

方法，该方法将

int

格式化为

String

。格式化程序“%4d”将采用一个

int

，并使其成为一个带前导空格的四字符

字符串

我们可以通过将格式化程序的三个部分放在一起来构造格式化程序

String formatter = "%" + width + "d";

下面是完整的可运行代码

public class MatrixPrint {
    public static void main(String[] args) {
        MatrixPrint mp = new MatrixPrint();

        int[][] matrix1 = {{1, 3, 4},
                {-124, 52, 6}};
        System.out.println(mp.printMatrix(matrix1));

        int[][] matrix2 = {{1, 2, 3, 4},
                {5, 6, 7, 8},
                {-9, -8, -7, -6}};
        System.out.println(mp.printMatrix(matrix2));

        int[][] matrix3 = {{2, 3, 4, 5},
                {7, 8, 9, 10},
                {-12, -11, -10, -9}};
        System.out.println(mp.printMatrix(matrix3));
    }

    public String printMatrix(int[][] matrix) {
        int width = largestWidth(matrix) + 1;
        String formatter = "%" + width + "d";
        return printMatrixElements(matrix, formatter);
    }

    private int largestWidth(int[][] matrix) {
        int maxWidth = 0;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                int width = Integer.toString(matrix[i][j]).length();
                maxWidth = Math.max(maxWidth, width);
            }
        }
        return maxWidth;
    }

    private String printMatrixElements(int[][] matrix, String formatter) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                builder.append(String.format(formatter, matrix[i][j]));
            }
            builder.append(System.lineSeparator());
        }
        return builder.toString();
    }
}

公共类MatrixPrint{
公共静态void main（字符串[]args）{
MatrixPrint mp=新的MatrixPrint（）；
int[][]矩阵1={{1,3,4}，
{-124, 52, 6}};
System.out.println（mp.printMatrix（matrix1））；
int[][]矩阵2={{1,2,3,4}，
{5, 6, 7, 8},
{-9, -8, -7, -6}};
System.out.println（mp.printMatrix（matrix2））；
int[][]矩阵3={{2,3,4,5}，
{7, 8, 9, 10},
{-12, -11, -10, -9}};
System.out.println（mp.printMatrix（matrix3））；
}
公共字符串打印矩阵（int[][]矩阵）{
整数宽度=最大宽度（矩阵）+1；
字符串格式化程序=“%”+宽度+“d”；
返回打印矩阵元素（矩阵、格式化程序）；
}
私有int最大宽度（int[][]矩阵）{
int maxWidth=0；
对于（int i=0；i
您可以使用方法并将每个数字表示为特定长度的字符串，包括表示负数的连字符。例如，如果数字已经是
String
格式，则可以使用：

//格式为三个字符的字符串
String str=String.format（“%3s”和“-11”）；

如果您有一个这样的字符串数组，您应该提前知道最小的负数或最大的正数，即最长的字符串。您的代码可能如下所示：

   1  3  4
-124 52  6

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

  2   3   4   5
  7   8   9  10
-12 -11 -10  -9

publicstaticvoidmain（字符串[]args）{
printArray（新字符串[][]{
{"1", "3", "4"},
{"-124", "52", "6"}}, 4);
printArray（新字符串[][]{
{"1", "2", "3", "4"},
{"5", "6", "7", "8"},
{"-9", "-8", "-7", "-6"}}, 2);
printArray（新字符串[][]{
{"2", "3", "4", "5"},
{"7", "8", "9", "10"},
{"-12", "-11", "-10", "-9"}}, 3);
}

publicstaticvoidprintary（字符串[][]arr，int-length）{
Arrays.stream（arr）
.map（行->数组.stream（行）
.map（str->String.format（“%”+长度+s”，str））
.collect（收集器.连接（“”））
.forEach（System.out:：println）；
}

输出：

   1    3    4
-124   52    6


另见：

•

•
这不是问题所在。我的问题是如何排列它们。你的意思是重新排列它们吗？就像它是一个10x5阵列，你希望它是5x10吗？也不是那样，但是如果你有兴趣的话，有一个答案可以完全回答我的问题。虽然这几乎是完美的，但它在每行的开头都放了不需要的空格。我用两个不同的格式化程序来抵消这一点。
  2   3   4   5
  7   8   9  10
-12 -11 -10  -9