4.12 2D Array Traversals

1. Row-major order: across each row

Nested iteration statements visit every element of a 2D array 4.12.A.1. In row-major order the traversal moves across each row: the outer loop picks a row and the inner loop visits every column of that row 4.12.A.1.

int[][] grid = { {1, 2, 3},
                 {4, 5, 6} };
for (int r = 0; r < grid.length; r++)          // rows: slow
{
    for (int c = 0; c < grid[0].length; c++)   // columns: fast
    {
        System.out.print(grid[r][c] + " ");
    }
    System.out.println();
}

Output:

1 2 3 
4 5 6 

Visit order (each cell shows when it is visited):

	col 0	col 1	col 2
row 0	1st	2nd	3rd
row 1	4th	5th	6th

2. Column-major order: down each column

In column-major order the traversal moves down each column 4.12.A.1. Put the column loop outside and the row loop inside. The bounds swap too, but the element is still grid[r][c].

int[][] grid = { {1, 2, 3},
                 {4, 5, 6} };
for (int c = 0; c < grid[0].length; c++)       // columns: slow
{
    for (int r = 0; r < grid.length; r++)      // rows: fast
    {
        System.out.print(grid[r][c] + " ");
    }
}
System.out.println();

Output:

1 4 2 5 3 6 

	col 0	col 1	col 2
row 0	1st	3rd	5th
row 1	2nd	4th	6th

Watch out: if you keep r < grid[0].length as the inner bound, then on this 2 by 3 array r reaches 2 and grid[2][0] throws an ArrayIndexOutOfBoundsException.

3. Uniquely defined orders and parts of the array

Nested loops can also visit elements in an order you define, or only an ordered sequence of them 4.12.A.1. Change where a loop starts, where it stops and how it steps.

int[][] grid = { {1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9} };

// bottom row to top row, right to left
for (int r = grid.length - 1; r >= 0; r--)
{
    for (int c = grid[0].length - 1; c >= 0; c--)
    {
        System.out.print(grid[r][c] + " ");
    }
}
System.out.println();

// main diagonal only: one loop is enough
for (int i = 0; i < grid.length; i++)
{
    System.out.print(grid[i][i] + " ");
}
System.out.println();

// zigzag: even rows left to right, odd rows right to left
for (int r = 0; r < grid.length; r++)
{
    if (r % 2 == 0)
    {
        for (int c = 0; c < grid[r].length; c++)
        {
            System.out.print(grid[r][c] + " ");
        }
    }
    else
    {
        for (int c = grid[r].length - 1; c >= 0; c--)
        {
            System.out.print(grid[r][c] + " ");
        }
    }
}
System.out.println();

Output:

9 8 7 6 5 4 3 2 1 
1 5 9 
1 2 3 6 5 4 7 8 9 

Tip for tracing: write the values of r and c in the order the loops produce them, then read the grid at each pair.

4. Nested enhanced for loops

Because a 2D array is an array of arrays, an enhanced for loop works on it the same way as on a 1D array 4.12.A.1. The outer loop visits the rows, so its variable must have the row type, a 1D array. The inner loop visits one row, so its variable has the element type 4.12.A.2.

2D array type	Outer variable (a row)	Inner variable (an element)
int[][]	int[] row	int value
double[][]	double[] row	double value
String[][]	String[] row	String value

String[][] teams = { {"Ada", "Bo"},
                     {"Cy", "Dee"},
                     {"Eli", "Fay"} };
int letters = 0;
for (String[] row : teams)
{
    for (String name : row)
    {
        letters += name.length();
    }
}
System.out.println(letters + " letters");

Output:

16 letters

A nested enhanced for loop always visits elements in row-major order, and it gives no indexes. Use indexed loops when you need column-major order or the position of an element.

5. Assigning to the loop variable does not change the array

The enhanced for loop variable gets a copy of each element value. Assigning a new value to it does not change the value stored in the array 4.12.A.2.

int[][] marks = { {3, 7},
                  {5, 9} };
for (int[] row : marks)
{
    for (int m : row)
    {
        m = 0;               // changes only the copy
    }
}
System.out.println(marks[0][0] + " " + marks[1][1]);

for (int r = 0; r < marks.length; r++)
{
    for (int c = 0; c < marks[0].length; c++)
    {
        marks[r][c] = 0;     // changes the array
    }
}
System.out.println(marks[0][0] + " " + marks[1][1]);

Output:

3 9
0 0

Background: the outer variable row refers to the real row, so row[0] = 0; inside the outer loop would change the array. Assigning to the inner variable m never does.