Java Two-Dimensional Arrays: Traversal, Algorithms, and Safe Mutation

Representing Rows, Columns, and Elements

A two-dimensional array organizes related values by rows and columns. In Java, it is an array of arrays, so an element is selected with a row index first and a column index second: array[row][column].

Indexes begin at $0$. For example, in int[][] scores = {{84, 91, 76}, {88, 95, 82}, {79, 86, 90}};, scores[0][0] is 84, scores[0][2] is 76, and scores[2][1] is 86.

The expression scores.length gives the number of rows. The expression scores[row].length gives the number of columns in the selected row. AP Computer Science A generally works with rectangular arrays, in which each row has the same length, but the row-specific expression accurately describes how Java stores the structure.

An array created with new receives default values. For example, new int[3][4] creates three rows with four integer positions in each row. The default is 0 for int, 0.0 for double, false for boolean, and null for reference types such as String.

Takeaway: Read a two-dimensional array as array[row][column], use zero-based indexes, and obtain a column bound from the row being processed.

Traversing a Two-Dimensional Array

A nested loop is the usual structure for visiting every element. In Row-major order, the outer loop chooses a row and the inner loop visits that row’s columns from left to right. The pattern is: for each row from 0 while row < values.length, process each col from 0 while col < values[row].length, using values[row][col].

For grid = {{1, 2, 3}, {4, 5, 6}}, row-major traversal visits 1, 2, 3, 4, 5, and 6 in that order.

In Column-major order, the outer loop chooses a column and the inner loop visits that column’s rows. For a rectangular grid, the column loop can use grid[0].length, while the row loop uses grid.length. The same example is visited as 1, 4, 2, 5, 3, and 6.

If a rectangular array has $r$ rows and $c$ columns, a complete traversal processes $r \times c$ elements. When tracing, hold the outer-loop value fixed, complete the inner loop, then advance the outer loop and restart the inner loop.

Takeaway: The outer loop determines the primary direction of travel, while the inner loop completes the work for each selected row or column.

Computing Sums, Averages, Extremes, and Searches

Many grid algorithms share three steps: initialize a result, traverse the required elements, and update the result when appropriate.

For a total, initialize sum to 0 and add each element. For an average, maintain both a sum and a count, then return (double) sum / count; the cast preserves a fractional result instead of performing only integer division.

For a maximum, initialize the result with the first element, such as data[0][0], rather than with 0. This remains correct when all values are negative. A counting algorithm increments its counter only when a condition is true; for example, an even-number test uses data[row][col] % 2 == 0.

A row algorithm keeps row fixed while changing col. A column algorithm keeps col fixed while changing row. A row sum therefore traverses data[row][col] for each valid column, whereas a column sum traverses the same expression for each valid row.

Searches often use short-circuiting. A method that asks whether any element is negative can return true at the first value satisfying data[row][col] < 0; if traversal finishes without finding one, it returns false. A method asking whether all values are positive can return false as soon as it finds a value satisfying data[row][col] <= 0; if no such value appears, it returns true.

Takeaway: Choose an initialization that matches the operation, update only when required, and stop as soon as the answer is determined.

Comparing Neighbors Without Leaving the Array

Neighbor comparisons require bounds based on the second position being accessed. To compare consecutive values in a row, the algorithm uses both data[row][col] and data[row][col + 1]. Therefore, the column loop must stop before the final column, using a condition such as col < data[row].length - 1.

To compare vertical neighbors, the algorithm uses both data[row][col] and data[row + 1][col]. Therefore, the row loop must stop before the final row, using a condition such as row < data.length - 1.

These rules protect an index bound. If an array has length $n$, its final valid index is $n - 1$. An expression using index + 1 is valid only when index is at most $n - 2$.

Common mistakes include using <= data.length, using the number of rows as the column limit, and reversing data[row][col] into data[col][row]. The correct column bound is usually data[row].length, because the number of rows and columns need not be the same.

Takeaway: Design every loop bound around the largest index expression that the algorithm will evaluate.

Shifting and Reversing Data Safely

Algorithms that move values must protect data before an assignment overwrites it. To shift one row right by one position, first save the last value, move values from right to left, and then place the saved value in the first position. Moving from left to right would repeatedly copy values that had already been shifted.

A row reversal uses two indexes, left and right. While left < right, exchange the values at the two positions, then increase left and decrease right. A temporary variable is needed because assigning one position directly to the other would lose the original value in the destination position.

Only about half of the row requires processing: each exchange handles two positions and moves both boundaries toward the center. Also distinguish inspection from mutation. Reading data[row][col] does not change the array, while data[row][col]++ changes the stored value.

The same reasoning applies to shifts or reversals of columns: save values that would be overwritten, choose a safe direction of movement, and update indexes toward the stopping condition.

Takeaway: Preserve values before overwriting them, choose the movement direction carefully, and verify that every assignment is intentional.

Tracing and Checking Two-Dimensional-Array Algorithms

Use a consistent tracing process to connect the array layout with the program’s state changes.

1. Draw the array and label its row and column indexes.

2. Record the initial values of the outer and inner loop variables.

3. Follow the inner loop one iteration at a time.

4. Record each accessed value, result update, and mutation.

5. When the inner loop ends, advance the outer loop and restart the inner loop.

6. Check the final returned value or the final state of the array.

For a full rectangular traversal with $r$ rows and $c$ columns, the number of element accesses is $r \times c$. For a horizontal-neighbor comparison, there are fewer comparisons because the final column has no column to its right. For a vertical-neighbor comparison, the final row has no row below it.

Before accepting an algorithm, check whether the first index consistently represents the row, whether each ordinary bound uses <, whether each column loop uses data[row].length, and whether expressions such as row + 1 or col + 1 have safe limits. If the algorithm modifies values, also verify the temporary storage and movement direction.

Takeaway: Accurate tracing depends on four connected ideas: representation, traversal order, safe bounds, and intentional state changes.