Массивы (двумерные)

Во многих задачах нужно работать не с одной строкой чисел, а с таблицей:
оценки по предметам (класс × предмет), игровое поле, матрица чисел, карта с высотами.

Для этого в Java удобно использовать двумерные массивы.

Двумерный массив можно представлять как таблицу или сетку:

int[][] a = new int[3][4];  // 3 строки, 4 столбца

У такого массива есть элементы a[0][0], a[0][1], …, a[2][3].

Краткая сводка

Двумерный массив целых чисел:

int[][] a = new int[n][m];   // n строк, m столбцов

a[i][j] = 10;                 // записать значение в ячейку (i, j)
int x = a[i][j];              // прочитать значение

int rows = a.length;          // количество строк
int cols = a[0].length;       // количество столбцов в первой строке

Важно:

индексы по строкам: от 0 до a.length - 1;
индексы по столбцам: от 0 до a[i].length - 1;
новый int[][] по умолчанию заполнен нулями.

Идея двумерного массива

Один массив — это «линейка» значений:

int[] line = new int[5];  // 5 чисел подряд

Двумерный массив — это «таблица» или «поле»:

int[][] a = new int[3][4]; // 3 строки, 4 столбца

Можно думать о нём как об «массиве массивов»:

a[0] — первая строка (массив int[]);
a[1] — вторая строка;
a[i][j] — элемент в i‑й строке и j‑м столбце.

Объявление и создание двумерного массива

Общий шаблон:

тип[][] имя = new тип[числоСтрок][числоСтолбцов];

Примеры:

int n = 3;
int m = 4;

int[][] a = new int[n][m];         // таблица n × m из целых
double[][] d = new double[5][5];   // 5 × 5 вещественных
boolean[][] used = new boolean[n][m]; // поле посещённых клеток

Можно создать и заполнить массив сразу литералами:

int[][] table = {
    {1, 2, 3},
    {4, 5, 6}
};
// 2 строки, 3 столбца

Чтение двумерного массива из ввода

Часто во входе сначала даны размеры n и m, затем n × m чисел.

import java.util.Scanner;

public class Read2DArrayExample {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();          // число строк
        int m = in.nextInt();          // число столбцов

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

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                a[i][j] = in.nextInt();
            }
        }

        // вывод массива в виде таблицы
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Здесь внешний цикл идёт по строкам (индекс i), внутренний — по столбцам (индекс j).

Сумма всех элементов

int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        a[i][j] = in.nextInt();
    }
}

int sum = 0;

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        sum = sum + a[i][j];
    }
}

System.out.println(sum);

Суммы по строкам и столбцам

Суммы по строкам

int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        a[i][j] = in.nextInt();
    }
}

for (int i = 0; i < n; i++) {
    int rowSum = 0;
    for (int j = 0; j < m; j++) {
        rowSum = rowSum + a[i][j];
    }
    System.out.println(rowSum);
}

Суммы по столбцам

int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        a[i][j] = in.nextInt();
    }
}

for (int j = 0; j < m; j++) {
    int colSum = 0;
    for (int i = 0; i < n; i++) {
        colSum = colSum + a[i][j];
    }
    System.out.println(colSum);
}

Двумерный массив как игровое поле

Двумерный массив удобно использовать для представления игрового поля:
0 — пустая клетка, 1 — стена, 2 — персонаж и т.п.

int n = in.nextInt();
int m = in.nextInt();
int[][] field = new int[n][m];

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        field[i][j] = in.nextInt();
    }
}

Пример проверки соседних клеток (аккуратно с границами):

int i = in.nextInt();
int j = in.nextInt();

// проверяем, есть ли клетка сверху
if (i > 0) {
    int up = field[i - 1][j];
}

// снизу
if (i + 1 < n) {
    int down = field[i + 1][j];
}

Что нужно запомнить

Двумерный массив можно представлять как таблицу n × m:

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

Первый индекс — номер строки, второй — номер столбца: a[i][j].

Размеры: a.length — количество строк, a[i].length — количество столбцов в строке i.
Типичный приём — вложенные циклы for по строкам и столбцам для чтения, обработки и вывода таблицы.