Two-dimensional arrays (2D arrays)

Some data is naturally in the shape of a table: the grade of each student in a class on each exam, a chessboard, the seats in a cinema hall, a matrix. In Java a two-dimensional array is used for this. There are few new concepts, but you have to apply the 1D array rules correctly with two indexes. Typical exam questions: “what does this nested loop print when it traverses the 2D array?” and “write a method that returns the row/column sum”.

Golden rules:

1. m[r][c]: first the row, then the column.
2. m.length is the number of rows, m[r].length is the number of columns of that row.
3. Outer loop is the row, inner loop is the column (row by row, row-major).
4. A 2D array is an array of arrays. m[r] is a 1D array in its own right.
5. For the column bound, write m[r].length, not a fixed number. It works correctly with ragged arrays too.

Creating

int[][] grid = new int[3][4];        // 3 rows, 4 columns, all 0
grid[0][1] = 5;
grid[2][3] = 9;
System.out.println(grid.length + " " + grid[0].length + " " + grid[0][1] + " " + grid[1][1]);

3 4 5 0

          column 0  column 1  column 2  column 3
row 0        0         5         0         0
row 1        0         0         0         0
row 2        0         0         0         9

If you know the values from the start, use the initializer list: each inner curly-brace group is a row.

int[][] m = {
    {1, 2, 3},
    {4, 5, 6}
};

Traversing and printing

for (int r = 0; r < m.length; r++) {
    for (int c = 0; c < m[r].length; c++) {
        System.out.print(m[r][c] + " ");
    }
    System.out.println();               // the row is finished
}
System.out.println(m[1][0] + " " + m[0][2] + " " + m.length + " " + m[1].length);
System.out.println(Arrays.toString(m[1]));
System.out.println(Arrays.deepToString(m));

1 2 3 
4 5 6 
4 3 2 3
[4, 5, 6]
[[1, 2, 3], [4, 5, 6]]

m[1] is the whole second row, that is, the array {4, 5, 6}; that is why Arrays.toString(m[1]) works. To see the whole table on one line, use Arrays.deepToString.

For an aligned table use a printf width:

for (int[] row : m) {
    for (int v : row) System.out.printf("%4d", v * 10);
    System.out.println();
}

  10  20  30
  40  50  60

Enhanced for can be nested too: the type of the outer variable is int[] (a row), the type of the inner one is int (a cell).

Traversing column by column

If you swap the places of the loops, the table is read column by column. In a rectangular array, m[0].length is used for the column bound:

for (int c = 0; c < m[0].length; c++) {
    for (int r = 0; r < m.length; r++) System.out.print(m[r][c] + " ");
}

1 4 2 5 3 6 

Sums, maximum, diagonal

public static int total(int[][] m) {
    int t = 0;
    for (int[] row : m)
        for (int v : row)
            t += v;
    return t;
}
public static int[] rowSums(int[][] m) {
    int[] sums = new int[m.length];               // one sum for each row
    for (int r = 0; r < m.length; r++)
        for (int c = 0; c < m[r].length; c++)
            sums[r] += m[r][c];
    return sums;
}
public static int colSum(int[][] m, int c) {
    int s = 0;
    for (int r = 0; r < m.length; r++) s += m[r][c];
    return s;
}
public static int max(int[][] m) {
    int best = m[0][0];
    for (int r = 0; r < m.length; r++)
        for (int c = 0; c < m[r].length; c++)
            if (m[r][c] > best) best = m[r][c];
    return best;
}
// main: m = {{1, 2, 3}, {4, 5, 6}}
System.out.println(total(m) + " " + Arrays.toString(rowSums(m)) + " " + colSum(m, 1) + " " + max(m));

21 [6, 15] 7 6

The trace table of rowSums, for m = {{1, 2, 3}, {4, 5, 6}}:

r   c   m[r][c]   sums
0   0   1         [1, 0]
0   1   2         [3, 0]
0   2   3         [6, 0]
1   0   4         [6, 4]
1   1   5         [6, 9]
1   2   6         [6, 15]

In a row sum the row is fixed and the column varies. In a column sum the column is fixed and the row varies. Thinking about which one stays fixed is the short way to set up the loop correctly.

Diagonals (in a square array)

int[][] sq = {
    {2, 0, 1},
    {3, 5, 4},
    {9, 8, 6}
};
int diag = 0;
for (int i = 0; i < sq.length; i++) diag += sq[i][i];                    // main diagonal
int anti = 0;
for (int i = 0; i < sq.length; i++) anti += sq[i][sq.length - 1 - i];    // anti-diagonal

13
15

On the main diagonal the row and column indexes are equal: 2 + 5 + 6. On the anti-diagonal they add up to n - 1: sq[0][2] + sq[1][1] + sq[2][0] = 1 + 5 + 9. For a diagonal a single loop is enough.

Transpose

Turning rows into columns: the dimensions of the new array are swapped, t[c][r] = m[r][c]. For {{1, 2, 3}, {4, 5, 6}}:

[[1, 4], [2, 5], [3, 6]]

Filling with a formula

If every cell is computed from the indexes, like a multiplication table:

int[][] table = new int[3][3];
for (int r = 0; r < 3; r++)
    for (int c = 0; c < 3; c++)
        table[r][c] = (r + 1) * (c + 1);
System.out.println(Arrays.deepToString(table));

[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

Arrays of arrays and ragged arrays

int[][] m is really an array each of whose elements is an int[]. m itself holds the references of the rows. That is why:

• int[] row = m[0]; takes the reference of the first row; row[1] = 20 directly changes m[0][1].
• The lengths of the rows can differ: a ragged array (ragged / jagged array).

int[][] tri = new int[4][];              // 4 rows, no columns yet
for (int r = 0; r < tri.length; r++) {
    tri[r] = new int[r + 1];             // r+1 elements in row r
    for (int c = 0; c <= r; c++) tri[r][c] = r + c;
}
for (int[] row : tri) System.out.println(Arrays.toString(row));
int[][] jag = {{1}, {2, 3, 4}, {5, 6}};
System.out.println(jag.length + " " + jag[1].length + " " + jag[2][1]);

[0]
[1, 2]
[2, 3, 4]
[3, 4, 5, 6]
3 3 6

PITFALL · writing the number of columns as a constant. When the inner loop on the jag array was written as c < 3, the first (single-element) row gave ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1. When it was written as c < jag[0].length it did not crash, but only the first element of each row was added up: 8 (the correct answer is 21). Use m[r].length for each row.

Passing a 2D array to a method

The same rule as 1D: a copy of the reference goes, and if the method changes the cells, the caller sees it too. The parameter type is int[][], and the return type can also be int[][] (as in transpose). You do not need to pass the number of rows and columns as separate parameters; you find them out inside the method with length.

Common mistakes

int[][] m = {{4, 7}, {1, 9}, {3, 2}};
System.out.println(m.length + " " + m[0].length + " " + m[2][0] + " " + m[1][1]);

int[][] m = new int[2][3];
m[1][2] = 8;
m[0][0] = m[1][2] / 2;
int s = 0;
for (int[] row : m) for (int v : row) s += v;
System.out.println(s);

int[][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int s = 0;
for (int r = 0; r < 3; r++) s += m[r][2 - r];
System.out.println(s);

int[][] m = {{1, 2, 3}, {4, 5, 6}};
for (int c = 0; c < 3; c++) {
    for (int r = 0; r < 2; r++) System.out.print(m[r][c]);
    System.out.print(" ");
}

int[][] m = new int[3][3];
for (int r = 0; r < 3; r++)
    for (int c = 0; c < 3; c++)
        m[r][c] = r * 3 + c;
System.out.println(m[2][1] + " " + m[1][2]);

int[][] m = {{5, 1}, {2, 8}, {6, 3}};
int cnt = 0;
for (int r = 0; r < m.length; r++)
    for (int c = 0; c < m[r].length; c++)
        if (m[r][c] > r * 3) cnt++;
System.out.println(cnt);

int[][] m = {{1}, {2, 3}, {4, 5, 6}};
int s = 0;
for (int r = 0; r < m.length; r++) s += m[r][m[r].length - 1];
System.out.println(s);

int[][] m = {{1, 2}, {3, 4}};
int[] row0 = m[0];
row0[1] = 20;
m[1] = new int[]{7, 7, 7};
System.out.println(m[0][1] + " " + m[1].length);

int[][] m = {{3, 1, 2}, {9, 4, 6}};
System.out.println(Arrays.toString(rowSums(m)) + " " + colSum(m, 0) + " " + max(m));