4.3 Two-Dimensional and Ragged Arrays

4.3 Two-Dimensional and Ragged Arrays

[!NOTE] Exam Focus: Two-dimensional arrays are a prominent evaluation domain on the 1Z0-811 examination. Candidates must understand Java's "array of arrays" memory architecture, distinguish between rectangular and ragged (jagged) arrays, recognize legal versus illegal allocation statements (especially the mandatory outer dimension rule), navigate nested loop traversals safely, and identify potential NullPointerException and ArrayIndexOutOfBoundsException hazards.

In many computing scenarios, data naturally presents itself in two or more dimensions: chessboard coordinates, spreadsheet rows and columns, graphical pixel grids, and matrix transformations. Java accommodates these structures through multidimensional arrays.

However, a crucial architectural concept distinguishes Java from languages like C, C++, or Fortran: Java does not allocate multidimensional arrays as contiguous, single-block memory matrices. Instead, Java implements multidimensional arrays strictly as arrays of arrays.

---

1. The "Array of Arrays" Memory Architecture

In Java, a two-dimensional array (int[][]) is fundamentally a one-dimensional array whose individual elements happen to hold reference pointers to other one-dimensional arrays.

Consider this allocation statement:

int[][] table = new int[3][2];

Here is how the JVM allocates this structure across heap memory:

1. The local variable table is a reference variable on the call stack containing the heap address of a top-level array object.
2. The top-level array object has a .length of 3. Its three elements (table[0], table[1], table[2]) do not store integer numbers; they store reference pointers capable of referring to int[] array objects.
3. The JVM automatically instantiates three separate, independent int[] array objects on the heap, each having a .length of 2.
4. The heap addresses of these three sub-arrays are stored into table[0], table[1], and table[2].
5. Each sub-array contains two primitive integer slots initialized to the default value 0.

Because each row is a completely independent object on the heap, the rows do not need to reside in contiguous physical memory, nor do they need to share identical lengths!

---

2. Declaring 2D Array Variables

Like single-dimensional arrays, square brackets can be attached to the data type or the identifier name:

int[][] matrix1; // Recommended: both bracket pairs attached to data type
int matrix2[][]; // Permissible: both bracket pairs attached to identifier
int[] matrix3[]; // Legal but confusing: split bracket placement

All three statements declare a two-dimensional array of integers. However, when multiple variables are declared in a single comma-separated statement, bracket distribution dictates the dimension of each variable:

int[][] a, b;   // 'a' is 2D (int[][]), 'b' is 2D (int[][])
int[] a[], b;   // 'a' is 2D (int[][]), 'b' is 1D (int[])
int a[][], b[]; // 'a' is 2D (int[][]), 'b' is 1D (int[])
int a[][], b;   // 'a' is 2D (int[][]), 'b' is a scalar primitive int

---

3. Allocating Rectangular Arrays

A rectangular array (uniform matrix) is a 2D array where every row contains the exact same number of columns. A rectangular array can be allocated in a single statement by specifying both dimensions:

int[][] grid = new int[2][3]; // 2 rows, 3 columns

This single statement creates:

• 1 outer array object with .length == 2.
• 2 inner array objects, each with .length == 3.
• A total of $2 \times 3 = 6$ primitive integer slots.

2D Literal Initializers

You can declare, allocate, and populate a rectangular array in a single expression using nested curly braces:

int[][] grid = {
    {10, 20, 30},
    {40, 50, 60}
};

System.out.println(grid[0][1]); // Prints: 20 (row 0, column 1)
System.out.println(grid[1][2]); // Prints: 60 (row 1, column 2)

---

4. The Mandatory Outer Dimension Rule (High-Yield Exam Rule)

When instantiating a multidimensional array with the new operator, Java strictly enforces the following syntactic constraint:

[!IMPORTANT] Mandatory Outer Dimension: You must specify the size of the first (outermost/highest-order) dimension. Inner dimensions may be omitted during initial instantiation, but the first dimension can never be omitted.

int[][] valid1 = new int[3][4]; // Legal: both dimensions specified
int[][] valid2 = new int[3][];  // Legal: first dimension specified, second omitted

int[][] invalid1 = new int[][4]; // COMPILE ERROR: cannot omit the first dimension
int[][] invalid2 = new int[][];  // COMPILE ERROR: array dimension missing

Why does Java enforce this? The JVM must allocate the top-level outer array object immediately on the heap. To allocate that object, it must know how many reference slots to create. If the outer size is missing, the JVM cannot instantiate the container object.

---

5. Ragged (Jagged) Arrays Architecture & Two-Step Allocation

Because a 2D array is an array of object references pointing to other arrays, there is no requirement that the inner arrays have identical capacities. An array in which different rows have different lengths is called a ragged array or jagged array.

Two-Step Dynamic Allocation

To construct a ragged array, you allocate the outer array by specifying only the first dimension while leaving the second bracket pair empty:

// Step 1: Allocate outer array of reference slots (length 3)
int[][] ragged = new int[3][];

At this point, ragged.length is 3. What do ragged[0], ragged[1], and ragged[2] contain? Because the component type of ragged is an object reference (int[]), every slot is initialized to null!

Next, you allocate each individual row with its own specific capacity:

// Step 2: Individually allocate each inner array
ragged[0] = new int[2]; // Row 0 has 2 columns
ragged[1] = new int[4]; // Row 1 has 4 columns
ragged[2] = new int[1]; // Row 2 has 1 column

Ragged Array Literal Initializer

A ragged array can also be created compactly using nested initializer lists of differing lengths:

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

System.out.println(triangle.length);    // Prints: 3 (rows)
System.out.println(triangle[0].length); // Prints: 1 (columns in row 0)
System.out.println(triangle[1].length); // Prints: 2 (columns in row 1)
System.out.println(triangle[2].length); // Prints: 3 (columns in row 2)

---

6. Traversing 2D Arrays with Nested Loops

Traversing a 2D array requires two nested loops:

• The outer loop iterates over rows from 0 to matrix.length - 1.
• The inner loop iterates over columns for that specific row from 0 to matrix[row].length - 1.

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

// Traditional nested for loop (safe for both rectangular and ragged arrays)
for (int r = 0; r < matrix.length; r++) {
    for (int c = 0; c < matrix[r].length; c++) {
        System.out.print(matrix[r][c] + " ");
    }
    System.out.println();
}

Output:

1 2 
3 4 5 
6 

[!CAUTION] The Uniform Column Assumption Trap: In ragged arrays, never write the inner loop condition as c < matrix[0].length. If a subsequent row has fewer columns than row 0, the inner loop will attempt to access non-existent column indices and throw an ArrayIndexOutOfBoundsException. Always query the specific row's capacity: c < matrix[r].length.

Enhanced Nested for-each Loop Traversal

You can also traverse 2D arrays using enhanced for-each loops. Notice the types in each loop header:

for (int[] row : matrix) {       // 'row' is a 1D array (int[])
    for (int value : row) {      // 'value' is a scalar int primitive
        System.out.print(value + " ");
    }
    System.out.println();
}

---

7. Critical Runtime Traps: NullPointerException on Inner Rows

A favorite 1Z0-811 exam scenario involves instantiating only the outer dimension of a 2D array and attempting to read or write elements before allocating the inner rows:

int[][] table = new int[3][]; // table[0], table[1], table[2] are all null!

System.out.println(table.length);   // Prints: 3 (outer array exists)
System.out.println(table[0]);        // Prints: null
// System.out.println(table[0].length); // RUNTIME ERROR: NullPointerException!
// table[0][0] = 10;                    // RUNTIME ERROR: NullPointerException!

Attempting to access table[0].length or table[0][0] attempts to dereference a null reference, immediately causing the JVM to throw a java.lang.NullPointerException.