Java Multidimensional Arrays

A multidimensional array in Java is really an array of arrays — there is no true rectangular block of memory the way there is in some other languages. A 2D array like int[][] grid is an array where each element is itself a reference to another int array, and understanding this "array of arrays" model explains both the flexibility and the quirks multidimensional arrays have in Java.

Because each inner array is an independent object, multidimensional arrays in Java do not have to be perfectly rectangular. Each row can have a different length, producing what is called a jagged array — a pattern that is unusual in some languages but completely normal and often useful in Java.

Why it matters

Grids, tables, game boards and matrices are naturally two-dimensional. Java does not have true 2D arrays; it has arrays whose elements are themselves arrays. Understanding that explains why rows can have different lengths, why a.length and a[0].length are different numbers, and why a row can be null.

Declaring and Creating Rectangular 2D Arrays

A rectangular grid is declared as int[][] grid = new int[3][4];, creating 3 rows of 4 columns each, all pre-filled with default values. Array literals also work for 2D data: int[][] grid = {{1, 2, 3}, {4, 5, 6}}; creates two rows directly. Access uses two index pairs, grid[row][col], where the first index selects the inner array and the second selects an element within it.

Jagged Arrays

Because each row is a separate array object, rows can have different lengths. You can create the outer array first with new int[3][] (note the empty second bracket), then assign each row its own array of any length. This is genuinely useful for data like a triangular table or a list of variable-length records, and it is a natural consequence of Java's "array of arrays" model rather than a special feature.

Iterating Multidimensional Arrays

A nested for or for-each loop is the standard way to visit every element: the outer loop walks the rows, and the inner loop walks the elements within the current row. Using for-each with int[] row : grid for the outer loop and int value : row for the inner loop reads cleanly and works correctly for jagged arrays too, since each row's own length is used automatically.

Example

public class MultiDimArrayDemo {
    public static void main(String[] args) {
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6}
        };

        int sum = 0;
        for (int[] row : grid) {
            for (int value : row) {
                sum += value;
            }
        }
        System.out.println("Sum: " + sum);

        int[][] jagged = new int[3][];
        jagged[0] = new int[]{1};
        jagged[1] = new int[]{1, 2};
        jagged[2] = new int[]{1, 2, 3};

        for (int[] row : jagged) {
            System.out.println(java.util.Arrays.toString(row));
        }
    }
}

Sum: 21
[1]
[1, 2]
[1, 2, 3]

Exercise

Add up the main diagonal of a square matrix — the elements where the row index equals the column index.

Expected output: 15 (1 + 5 + 9)

public class DiagonalSum {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int sum = 0;
        // TODO: add matrix[0][0], matrix[1][1], matrix[2][2] using a loop

        System.out.println(sum);
    }
}

public class DiagonalSum {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        int sum = 0;
        for (int i = 0; i < matrix.length; i++) {
            sum += matrix[i][i];
        }

        System.out.println(sum); // 15
    }
}

Quick quiz

Interview questions