Как я могу распечатать простую int[][] в формате матричной коробки, подобно тому формату, в котором мы записываем матрицы вручную. Простой цикл, по-видимому, не работает. Если это поможет, я пытаюсь скомпилировать этот код в терминале linux ssh.
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
System.out.println(matrix[i][j] + " ");
}
System.out.println();
}
final int[][] matrix = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
Производит:
1 2 3
4 5 6
7 8 9
Чтобы правильно отформатировать числа в столбцах, лучше всего использовать printf. В зависимости от того, насколько велики максимальные или минимальные числа, вы можете настроить шаблон "%4d". Например, чтобы разрешить любое целое число от Integer.MIN_VALUE до Integer.MAX_VALUE, используйте "%12d".
public void printMatrix(int[][] matrix) {
for (int row = 0; row < matrix.length; row++) {
for (int col = 0; col < matrix[row].length; col++) {
System.out.printf("%4d", matrix[row][col]);
}
System.out.println();
}
}
Пример вывода:
36 913 888 908
732 626 61 237
5 8 50 265
192 232 129 307
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
{10, 11, 12}
};
printMatrix(matrix);
public void printMatrix(int[][] m) {
try {
int rows = m.length;
int columns = m[0].length;
String str = "|\t";
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
str += m[i][j] + "\t";
}
System.out.println(str + "|");
str = "|\t";
}
} catch (Exception e) {
System.out.println("Matrix is empty!!");
}
}
Выход:
| 1 2 3 |
| 4 5 6 |
| 7 8 9 |
| 10 11 12 |
В стиле Java 8:
import java.util.Arrays;
public class MatrixPrinter {
public static void main(String[] args) {
final int[][] matrix = new int[4][4];
printMatrix(matrix);
}
public static void printMatrix(int[][] matrix) {
Arrays.stream(matrix).forEach((row) -> {
System.out.print("[");
Arrays.stream(row).forEach((el) -> System.out.print(" " + el + " "));
System.out.println("]");
});
}
}
Это производит:
[ 0 0 0 0 ]
[ 0 0 0 0 ]
[ 0 0 0 0 ]
[ 0 0 0 0 ]
Но раз уж мы здесь, почему бы не сделать раскладку строк настраиваемой?
Все, что нам нужно, это передать лямбу методу matrixPrinter:
import java.util.Arrays;
import java.util.function.Consumer;
public class MatrixPrinter {
public static void main(String[] args) {
final int[][] matrix = new int[3][3];
Consumer<int[]> noDelimiter = (row) -> {
Arrays.stream(row).forEach((el) -> System.out.print(" " + el + " "));
System.out.println();
};
Consumer<int[]> pipeDelimiter = (row) -> {
Arrays.stream(row).forEach((el) -> System.out.print("| " + el + " "));
System.out.println("|");
};
Consumer<int[]> likeAList = (row) -> {
System.out.print("[");
Arrays.stream(row).forEach((el) -> System.out.print(" " + el + " "));
System.out.println("]");
};
printMatrix(matrix, noDelimiter);
System.out.println();
printMatrix(matrix, pipeDelimiter);
System.out.println();
printMatrix(matrix, likeAList);
}
public static void printMatrix(int[][] matrix, Consumer<int[]> rowPrinter) {
Arrays.stream(matrix).forEach((row) -> rowPrinter.accept(row));
}
}
Вот результат:
0 0 0
0 0 0
0 0 0
| 0 | 0 | 0 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |
[ 0 0 0 ]
[ 0 0 0 ]
[ 0 0 0 ]
public static void printMatrix(double[][] matrix) {
for (double[] row : matrix) {
for (double element : row) {
System.out.printf("%5.1f", element);
}
System.out.println();
}
}
printMatrix(new double[][]{2,0,0},{0,2,0},{0,0,3}});
2.0 0.0 0.0
0.0 2.0 0.0
0.0 0.0 3.0
Начиная с Java 8:
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
Arrays.stream(matrix).map(Arrays::toString).forEach(System.out::println);
Выход:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Вот мой эффективный подход к отображению двумерного целочисленного массива с использованием массива StringBuilder.
public static void printMatrix(int[][] arr) {
if (null == arr || arr.length == 0) {
// empty or null matrix
return;
}
int idx = -1;
StringBuilder[] sbArr = new StringBuilder[arr.length];
for (int[] row : arr) {
sbArr[++idx] = new StringBuilder("(\t");
for (int elem : row) {
sbArr[idx].append(elem + "\t");
}
sbArr[idx].append(")");
}
for (int i = 0; i < sbArr.length; i++) {
System.out.println(sbArr[i]);
}
System.out.println("\nDONE\n");
}
Выход:
( 1 2 3 )
( 4 5 6 )
( 7 8 9 )
( 10 11 12 )
DONE
public class Matrix {
public static void main(String[] args) {
double Matrix[][] = {
{0*1, 0*2, 0*3, 0*4},
{0*1, 1*1, 2*1, 3*1},
{0*2, 1*2, 2*2, 3*2},
{0*3, 1*3, 2*3, 3*3}};
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++)
System.out.print(Matrix[i][j] + " ");
System.out.println();
}
}
}
Выход:
0.0 0.0 0.0 0.0
0.0 1.0 2.0 3.0
0.0 2.0 4.0 6.0
0.0 3.0 6.0 9.0
Я предпочитаю использовать расширенный цикл в Java
Поскольку наш ar представляет собой массив массивов [2D]. Итак, когда вы перебираете его, вы сначала получаете массив, а затем вы можете перебирать это array, чтобы получить отдельные элементы.
public static void main(String[] args) {
int[][] ar = {
{12, 33, 23},
{34, 56, 75},
{14, 76, 89},
{45, 87, 20}};
for (int[] num : ar) {
for (int ele : num) {
System.out.print(" " + ele);
}
System.out.println(" ");
}
}
Выход:
12 33 23
34 56 75
14 76 89
45 87 20
