Multi-Dimensional Arrays

Java does not support true contiguous multi-dimensional matrices in memory. Instead, all multi-dimensional arrays are represented as arrays of arrays. For example, a 2D array is a 1D array where each slot contains a reference to another 1D array.

Row-Major vs Column-Major Locality

When iterating over a 2D array, always write nested loops in Row-Major order (outer loop is row counter, inner loop is column counter):

// Row-Major: highly performant (sequential accesses)
for (int row = 0; row < matrix.length; row++) {
    for (int col = 0; col < matrix[row].length; col++) {
        int val = matrix[row][col];
    }
}

This is because each row is an independent array object stored contiguously. Accessing elements of the same row sequentially allows the CPU to load the contiguous values into its fast L1/L2 caches. Traversing by column jumps between different row array objects, causing continuous cache misses and degrading execution speeds.

Common Pitfalls

• Assuming Contiguous Layouts: Treating a 2D array as a single contiguous memory block (like in C/C++). In Java, rows can be located in non-adjacent addresses on the heap.
• Swapping Row and Column index bounds: Writing matrix[col][row] instead of matrix[row][col]. This swaps coordinates and will cause a crash unless the matrix is perfectly square.
• Hardcoding inner loop limits: Writing col < 4 instead of col < matrix[row].length. This assumes uniform column dimensions, which fails for non-rectangular configurations.

Best Practices

• Always structure nested iteration loops in Row-Major order to maximize CPU cache utilization.
• Use matrix[row].length for the inner loop bounds to handle varying row lengths safely.
• Avoid creating deeply nested multi-dimensional arrays (like 3D or 4D), as they significantly complicate code readability and memory tracking.

Interview-Relevant Information