Arrays, two dimensions, and practice

A one-dimensional array is a row of boxes. That was enough to hold a list of test scores or a week of temperatures. But plenty of data comes as a grid: a chessboard, a spreadsheet, the pixels on a screen, the seats in a cinema. For those you want rows and columns at once. That is what a two-dimensional array gives you.

A quick warm-up on one dimension#

Before adding a second dimension, check that the first one is steady. Here is the pattern you already know: declare an array, walk it with a loop, and add the values into a running total. Press Run and step through it, watching total grow.

The loop ran three times, with i taking the values 0, 1 and 2, and it printed Sum is 60. Hold on to the shape of that loop. Most of this lesson puts one of these loops inside another.

A grid: rows and columns#

Suppose you want to store a small table of numbers, two rows of three:

Read the type slowly. int[] was “an array of int”. Now int[][]is “an array of arrays of int”, with two pairs of brackets because there are two dimensions. The literal has braces inside braces: the outer braces hold the whole grid, and each inner pair of braces is one row.

To reach a single cell you give two indexes. The first picks the row, the second picks the column inside that row, and both count from zero. So grid[0][0] is the very first cell, the 1 in the top-left corner. grid[1][2] is row 1 (the second row) and column 2 (the third number in it), which is the 6.

The same two indexes on the left of = change a cell. grid[0][1] = 20; replaces the 2 in row 0, and the last line of output shows the new value.

Here is the same grid drawn as rows and columns, with every index written in. Tap any cell to see the name Java uses for it. Then switch to the grid with three rows and find grid[2][0], which only exists once there is a row 2.

Key idea

A cell is named by two numbers: grid[row][column]. Row first, then column, and both start at zero. Swapping the two gives you a different cell, or an error.

How big is the grid? length in two directions#

With a 1D array, row.length told you how many boxes it had. A grid raises two questions: how many rows, and how many columns. The answer reuses .length; you just ask it of the right thing.

• grid.length is the number of rows. It asks the outer array how many inner arrays it holds.
• grid[r].length is the number of columns in row r. It asks one particular row how many numbers it holds.

grid.length is 2 (two rows) and grid[0].length is 3 (three columns). The plain grid.length never tells you the column count, because the outer array only knows how many rows there are. To count columns you first step into a row.

Visiting every cell with nested loops#

To touch every box in a 1D array you used one loop. A grid has rows and columns, so you use one loop inside another. The outer loop walks the rows. For each row it enters, the inner loop walks every column of that row. The inner loop finishes completely before the outer loop moves to the next row.

1. 1The outer loop sets r = 0 (the first row).
2. 2The inner loop runs fully: c = 0, then 1, then 2, visiting every cell in row 0.
3. 3The outer loop moves on: r = 1 (the second row).
4. 4The inner loop runs fully again for row 1: c = 0, 1, 2.
5. 5The outer loop has no more rows, so the whole thing stops.

That is six visits in total, two rows times three columns, which is exactly the number of cells. Here is the pattern in code, summing the whole grid into one total. Press Run and step through it: for each value of r, c runs through 0, 1 and 2. To watch the same order on a drawn grid, choose Row by row in the grid widget above and press Play.

Trace the visits in order and you add 1 + 2 + 3 from the first row, giving 6, then 4 + 5 + 6 from the second, giving another 15. Together that is 21, exactly what it prints. The shape to memorise is the bounds: the outer loop stops at grid.length (the number of rows) and the inner loop stops at grid[r].length (the columns in the row it is on).

Printing the grid as a table

A useful trick: inside the inner loop, print each value with a space after it. Then, after the inner loop finishes one row, call println with nothing in it to drop to the next line. The inner loop draws a row from left to right; the empty println ends the row.

Watch where each statement sits. System.out.print is inside the inner loop, so it runs once per cell and keeps the cursor on the same line. The empty System.out.println()is inside the outer loop but outside the inner one, so it runs once per row, after all of that row's cells have been printed, and starts a fresh line. Move that println inside the inner loop and every number would land on its own line instead.

1public class Main {
2    public static void main(String[] args) {
3        char[][] board = {
4            {'X', 'O', 'X'},
5            {'.', 'X', 'O'},
6            {'O', '.', '.'}
7        };
8 
9        int empty = 0;
10        // TODO: visit every square. For each '.', print where it is,
11        // like "Empty: row 1, column 0", and add 1 to empty.
12 
13        System.out.println(empty + " squares left");
14    }
15}

Making an empty grid with new#

Listing every value works when you know them all up front. When you only know the size, ask for an empty grid with new, the way new int[5] made an empty row of five:

new int[3][4] means 3 rows of 4 columns: the row count comes first, in the same order as board[r][c]. Every cell starts at 0, the default for an int, just as in a new one-dimensional array. Then board[1][2] = 7; changes one cell, and the second line of output shows the 7 in the middle row.

Arrays.deepToString turns a whole grid into text, one pair of square brackets per row inside an outer pair. It lives in java.util.Arrays, which is why the program starts with an import line. It is the quick way to check what a grid holds. When you want to choose the layout yourself, use the printing loop from the last section.

A new grid is usually filled by the same nested loop, writing to each cell instead of reading it. This one builds a times table. The cell in row r, column c gets (r + 1) * (c + 1), because the indexes count from 0 and the table counts from 1.

The first pair of loops fills all 20 cells; the second pair prints them. Each value is followed by \t, the tab escape from variables and types, which lines the columns up even when a number has two digits.

What a 2D array really is: an array of arrays#

So far this page has called it a grid, and as a mental picture that works well. Underneath, Java has no special grid type. A 2D array is an array whose elements are themselves arrays.

So grid is an array of length 2. Each of its two elements is a whole one-dimensional array of int. grid[0] is the first inner array, {1, 2, 3}. grid[1] is the second, {4, 5, 6}. When you write grid[0][2], you are doing two ordinary array lookups in a row: first grid[0] hands you the array {1, 2, 3}, and then the second [2] indexes into that array to get 3.

The memory view shows this. Run the program below, step through it, and look at the memory view under the code. It holds three arrays: grid, whose two cells each hold a reference to a row (where that row lives in memory), and the two rows themselves, each an ordinary array of three numbers. After int[] top = grid[0]; the first row also goes by the name top.

Key idea

grid[r][c] is two lookups, one after the other. grid[r] selects a row, which is itself an array, and then [c] selects an element inside that row.

This one fact explains the two .length rules. grid.length is the length of the outer array, the number of rows. grid[r].lengthis the length of one inner array, the number of columns in that row. There is no special “column length” rule to learn; it is the ordinary length of an ordinary array that happens to live inside another one.

Rows of different lengths#

Because each row is its own array, nothing forces the rows to be the same length. A 2D array whose rows differ in length is called a jagged array. Here is one:

The outer array has three rows, so jagged.length is 3. Each row reports its own width: 2, then 3, then 1. This is why a safe loop asks grid[r].length instead of assuming a fixed number. With a fixed inner bound of c < 3, the loop would crash on the very first row, which has only two columns.

It prints 13. jagged[r].length - 1 is the last index of row r: 1 for the first row, 2 for the second and 0 for the third. So the loop adds 2, 5 and 6. Because every row is asked for its own length, the loop never steps off the end of a short row.

for-each over the rows#

The for-each loop from one-dimensional arrays works here too, and it shows the array of arrays plainly. Each element of grid is a row, so the outer loop variable has the type int[]:

Read for (int[] row : grid)as “for each row in the grid”. The inner loop then walks the numbers of that row. A for-each loop has no index, so use it when you only read values. When you need r and c, to change a cell or to print where something is, use the counting loops.

Building a jagged grid one row at a time#

You can also give new only the number of rows and leave the second pair of brackets empty. Then you make each row yourself:

new int[3][] makes the outer array with room for three rows, but no rows yet. Each slot starts as null, Java's value for “no array here”, which is what the first line prints. The loop then makes each row with its own new, one longer each time, so the second line shows rows of 1, 2 and 3 zeros. Step through it and watch the rows appear in the memory view one at a time.

A complete example: row, column and diagonal sums#

Here is a program that pulls the lesson together. It walks a square grid and adds up each row, each column, and both diagonals. Read it with the grid in front of you, then press Run.

The program does three jobs, and most grid problems turn out to be a mix of these three loops. Here is each one in turn.

Row sums: stand on a row, walk across it

The outer loop picks a row with r. The first thing it does inside is make a fresh rowSum of 0. That reset matters: every row needs its own total, so the counter starts again each time the loop steps onto a new row. Then the inner loop slides c across the columns, adding grid[r][c] as it goes. When the inner loop runs out of columns, rowSumholds that row's total, so the program prints it and moves down to the next row.

Column sums: the same idea, turned on its side

A column is a row read from top to bottom instead of left to right. So the adding stays the same, and the two loops swap places. Now c (the column) stays still on the outside while r (the row) walks down it, adding grid[r][c]. The cells and the additions are the same; only the order of the visits changes.

Swap the loops in the printing program from earlier, and you print the grid turned on its side. Decide what this prints before you run it.

It prints 1 4, then 2 5, then 3 6. The outer loop holds a column still, and the inner loop walks down the two rows of that column, so each printed line is one column of the grid. Choose Column by column in the grid widget below to watch this order.

The two diagonals: let the indexes do the walking

A diagonal is the line of cells running from one corner to the opposite corner. There are two of them. The trick is to watch how the row number and the column number relate to each other as you step down the grid. Press Next to step i from 0 to 2 and mark both diagonals on the 3 by 3 grid:

On the main diagonal (top left down to bottom right) the row and the column are always the same number: grid[0][0], then grid[1][1], then grid[2][2]. So a single grid[i][i] lands on all of them, which is why one loop is enough.

The anti-diagonal (top right down to bottom left) is the mirror image. As the row i goes 0, 1, 2 down the grid, the column has to go 2, 1, 0 backwards from the right edge. The last column index is rows - 1 (here 2), so the column for each step is rows - 1 - i: when i is 0 the column is 2, when i is 1 it is 1, and when i is 2 it is 0. The rows - 1 - i counts backwards while i counts forwards.

Key idea

Fixing the row on a diagonal fixes the column too, so each diagonal needs only one loop. Main diagonal: grid[i][i]. Anti-diagonal: grid[i][rows - 1 - i]. Both only make sense on a square grid, where the number of rows equals the number of columns.

1public class Main {
2    public static void main(String[] args) {
3        String[] players = {"Ana", "Ben", "Cy"};
4        int[][] scores = {
5            {7, 4, 9},
6            {5, 8, 6},
7            {10, 2, 3}
8        };
9 
10        // TODO: for each player (a row), print their total, like "Ana: 20"
11 
12        // TODO: for each round (a column), print its total, like "Round 1: 22"
13    }
14}

Back to one dimension: the problem set#

A grid reuses every single-row skill, so the one-dimensional moves are worth drilling until they are automatic. The end of one-dimensional arrays has ten problems, plus a bonus, solved with nothing but arrays and for loops. Some only read the array and report what they find: leaders, the longest increasing streak, frequency counts, the first repeating element, the mountain check and the balance point. Others build or rearrange an array: circular neighbor sums, the mirror difference, the wave and alternating signs.

A good order is to start with the ones that only read, then move to the ones that build. For each problem, decide what it prints before you run it, then step through it to check. When your predictions keep matching, the single-loop pattern is automatic, and a grid is that same pattern twice.

Warm-up questions, with answers#

A set of short coding questions to finish on, half about one-dimensional arrays and half about grids. Each one is small on purpose. Write the loop in your head or on paper first, then open the answer to check both the code and the reasoning. Every program runs, so you can press Full screen and step through it.

One-dimensional arrays

Two-dimensional arrays

Further reading#

• Creating Arrays in Your Programs, the dev.java tutorial, including arrays of arrays and rows of different lengths
• java.util.Arrays in the Java SE 25 API documentation, with deepToString and the other array helpers
• Arrays in the Java Language Specification, chapter 10, the exact rules for creating and indexing arrays