Как вывести двумерный массив в виде таблицы java

Двумерный массив в Java чаще всего используется для представления матриц, сеток или табличных данных. Стандартное представление такого массива – это массив массивов: int[][] array. Чтобы отобразить его содержимое в виде таблицы, требуется пройтись по каждому элементу, соблюдая структуру строк и столбцов.

Чтобы результат был читаемым, следует добавить символы табуляции (\t) или пробелы между элементами одной строки и переход на новую строку (\n) после каждой строки массива. Пример: System.out.print(array[i][j] + «\t»); и System.out.println(); после завершения внутреннего цикла.

Создание двумерного массива с фиксированными значениями

Для инициализации двумерного массива с заранее заданными значениями используется литерал массива. Пример для массива целых чисел:

int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Размер массива определяется автоматически по количеству вложенных массивов и длине каждой строки. Все строки должны содержать одинаковое количество элементов, если предполагается прямоугольная структура.

Если требуется зафиксировать значения вручную без использования литералов, используется следующая последовательность:

1. Создать массив с указанием размеров: int[][] matrix = new int[3][3];
2. Присвоить значения по индексам:
   • matrix[0][0] = 1;
   • matrix[0][1] = 2;
   • matrix[0][2] = 3;
   • matrix[1][0] = 4;
   • и т.д.

Для массивов других типов (например, String[][]) синтаксис аналогичен:

String[][] names = {
{"Анна", "Борис"},
{"Виктор", "Галина"}
};

Массивы с разным числом элементов в строках допускаются, но такие структуры теряют прямоугольность и требуют дополнительных проверок при обработке.

Заполнение двумерного массива данными из пользовательского ввода

Для считывания значений с клавиатуры используется класс Scanner. Необходимо заранее знать количество строк и столбцов массива.

Пример: ввод значений в массив int[3][4].

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int rows = 3;
int cols = 4;
int[][] array = new int[rows][cols];
Scanner scanner = new Scanner(System.in);
System.out.println("Введите 12 целых чисел:");
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
while (!scanner.hasNextInt()) {
System.out.println("Ошибка ввода. Введите целое число:");
scanner.next();
}
array[i][j] = scanner.nextInt();
}
}
}
}

System.out.printf("Элемент [%d][%d]: ", i, j);

Если требуется ввод строк, используется nextLine() вместо nextInt(). При этом массив должен быть объявлен как String[][].

String[][] words = new String[2][3];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
System.out.printf("Введите строку [%d][%d]: ", i, j);
words[i][j] = scanner.nextLine();
}
}

После завершения ввода сканер можно закрыть: scanner.close();. Это освобождает ресурсы, связанные с потоком ввода.

Пример:

int[][] data = {
{12, 5, 8},
{7, 14, 3},
{9, 0, 6}
};
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.printf("%4d", data[i][j]);
}
System.out.println();
}

System.out.printf("%4d", data[i][j]) гарантирует выравнивание столбцов. Ширина в 4 символа позволяет корректно отобразить числа до трёх знаков. Если значения могут быть длиннее, число в спецификаторе стоит увеличить.

String[][] data = {
{"ID", "Имя", "Возраст"},
{"1", "Анна", "23"},
{"2", "Борис", "34"},
{"3", "Виктория", "29"}
};
int columns = data[0].length;
int[] maxLengths = new int[columns];
for (String[] row : data) {
for (int i = 0; i < columns; i++) {
maxLengths[i] = Math.max(maxLengths[i], row[i].length());
}
}
for (String[] row : data) {
for (int i = 0; i < columns; i++) {
System.out.printf("%-" + (maxLengths[i] + 2) + "s", row[i]);
}
System.out.println();
}

Используется формат %-Ns, где N – ширина столбца, вычисленная на основе самой длинной строки. Добавление 2–3 пробелов после значения улучшает читаемость. Выравнивание происходит по левому краю. Для чисел лучше использовать %Nd без минуса, чтобы выровнять по правому краю:

int[][] numbers = {
{7, 123, 42},
{12, 4, 1056},
{3, 98, 6}
};
int cols = numbers[0].length;
int[] maxLens = new int[cols];
for (int[] row : numbers) {
for (int i = 0; i < cols; i++) {
maxLens[i] = Math.max(maxLens[i], String.valueOf(row[i]).length());
}
}
for (int[] row : numbers) {
for (int i = 0; i < cols; i++) {
System.out.printf("%" + (maxLens[i] + 2) + "d", row[i]);
}
System.out.println();
}

Для строк и чисел форматирование задаётся отдельно. Смешанные таблицы (например, заголовки – строки, данные – числа) требуют раздельной логики выравнивания. Также важно избегать жёстко заданной ширины: размеры должны определяться автоматически по содержимому.

• Для выравнивания по левому краю используйте %-Ns, где N – ширина столбца.
• Для выравнивания по правому краю – %Ns.
• Числа форматируются через %Nd (целые) или %N.2f (дробные с двумя знаками после запятой).

for (int[] row : data) {
for (int cell : row) {
System.out.printf("%5d", cell);
}
System.out.println();
}

Для выравнивания текста по левому краю строк:

String[][] names = {{"Иван", "Петров"}, {"Анна", "Сидорова"}};
for (String[] row : names) {
for (String cell : row) {
System.out.printf("%-10s", cell);
}
System.out.println();
}

• Следите, чтобы ширина столбцов была больше максимальной длины значения в ячейке, иначе структура собьётся.
• Избегайте табуляции – разные консоли интерпретируют её по-разному, лучше использовать фиксированную ширину.

Печать двумерного массива в JTable на Swing

Основной шаг заключается в преобразовании двумерного массива в Vector объектов, который далее передается в модель. Например, если у вас есть двумерный массив типа int[][], вам нужно создать соответствующие строки для каждого элемента массива и добавить их в таблицу.

Пример кода для печати двумерного массива:

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
public class ArrayToTable {
public static void main(String[] args) {
// Пример двумерного массива
int[][] data = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Заголовки столбцов
String[] columnNames = {"Column 1", "Column 2", "Column 3"};
// Преобразование массива в структуру для JTable
Object[][] tableData = new Object[data.length][data[0].length];
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
tableData[i][j] = data[i][j];
}
}
// Создание модели таблицы
DefaultTableModel model = new DefaultTableModel(tableData, columnNames);
// Создание JTable с моделью
JTable table = new JTable(model);
// Создание окна для отображения JTable
JFrame frame = new JFrame("Таблица данных");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new JScrollPane(table));
frame.pack();
frame.setVisible(true);
}
}

В этом примере двумерный массив data конвертируется в формат, подходящий для модели DefaultTableModel, которая передается в таблицу JTable. Заголовки столбцов задаются в массиве columnNames, и они отображаются в верхней части таблицы.

Обратите внимание, что для корректного отображения таблицы необходимо обернуть JTable в JScrollPane, чтобы пользователь мог прокручивать данные при необходимости.

Основной принцип заключается в построении строки, содержащей HTML-разметку таблицы. Затем эту строку можно вставить в нужное место в документе. Рассмотрим пример реализации такого подхода.

Пример кода на Java:

public class ArrayToTable {
public static void main(String[] args) {
int[][] array = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
StringBuilder tableHTML = new StringBuilder("");
for (int i = 0; i < array.length; i++) {
tableHTML.append("");
for (int j = 0; j < array[i].length; j++) {
tableHTML.append("");
}
tableHTML.append("");
}
tableHTML.append("
").append(array[i][j]).append("
");
System.out.println(tableHTML.toString());
}
}

Объяснение: В данном примере создается строка с тегами HTML для таблицы. Мы начинаем с тега <table>, затем перебираем элементы двумерного массива и для каждого значения генерируем строки таблицы с помощью тегов <tr>.