How Do 2D Arrays Work in Java?

Java has no true two-dimensional array type. int[][] grid declares an array whose elements are themselves arrays of int — an array of arrays, also called a ragged array structure. That has a concrete consequence: grid.length is the number of rows, and grid[0].length is the number of columns in the first row, but nothing forces the other rows to have the same length.

When you write new int[3][4], the JVM allocates one array of three references and then three separate int arrays of four elements each. The rows are entirely independent objects. Writing grid[1][2] = 7 reaches into the second row object; nothing is shared with the first row.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] grid = new int[3][4];          // 3 rows, 4 columns
        System.out.println("rows            : " + grid.length);
        System.out.println("columns in row 0: " + grid[0].length);

        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[r].length; c++) {
                grid[r][c] = r * 10 + c;
            }
        }
        for (int[] row : grid) {
            System.out.println(Arrays.toString(row));
        }

        // Every row is a separate object.
        System.out.println("rows are distinct: " + (grid[0] != grid[1]));
    }
}

Because the rows are separate objects, the inner loop must use grid[r].length rather than a hard-coded column count. That is exactly what makes jagged arrays possible: you can build rows of different lengths, and the idiomatic traversal still works because each row knows its own size.

One memory point: the outer array holds references, so a 2D array of a million cells is a million ints plus a handful of row objects. If you need a genuinely rectangular block of primitives with no indirection, a single flat array with a computed index is faster, and libraries like Apache Commons Math use that layout for large matrices.

You get a NullPointerException. new int[3][] allocates an array of three references and fills them with null — it deliberately does not create the inner arrays, because it does not know how long they should be. The moment you write grid[0][0] = 5, the JVM dereferences a null reference and throws.

The distinction between new int[3][4] and new int[3][] is worth stating precisely. The first creates the outer array and three inner arrays of length four, fully initialised to zero. The second creates only the outer array; each inner array must be created separately before it can be used.

To use the jagged form you allocate each row yourself, typically grid[0] = new int[4]; for each index, and only then start writing into it. Once the rows exist, grid[0][0] = 5 is perfectly safe.

Jagged arrays are useful when the rows genuinely differ in length — a sparse matrix, a table where some rows are missing, a ragged text file. For a rectangular grid they are pure overhead, because every access goes through two levels of indirection and the row objects are scattered in memory rather than laid out contiguously.

The related trap is the same one seen with collections: new int[3][] gives you three nulls, not three empty arrays, so a loop that tries to write into row i fails on the first iteration unless you allocate the rows first. If you are unsure, allocating the inner arrays in the same loop that fills them is the habit to build.