2D Array Creation and Access

A teacher keeps quiz scores for three students, Ana, Ben, and Cy, on four quizzes each. On paper that is a small table: one line per student, one box per quiz. With the 1D arrays from Topic 4.3 you could make one array per student:

int[] anaScores = {90, 85, 77, 92};
int[] benScores = {68, 74, 81, 88};
int[] cyScores = {95, 91, 89, 100};

That works for three students, but a class of thirty would need thirty variables with thirty names, and there would be no single variable that holds “the whole class.” What the teacher wants is one variable for the whole table.

Here is the key observation. A 1D array can hold any type of element: int values, String references, and so on. An array is itself an object, so a 1D array can also hold references to other arrays. Put the three student arrays into one outer array, and that outer array holds the whole table. Java calls this a two-dimensional array, or 2D array: an array whose elements are themselves 1D arrays of the same type. That is why people describe a 2D array as an array of arrays.

You can picture it in two ways. The first is a grid. Each inner array is a row, one line across the grid. The boxes at the same position in every row line up into a column, one line going down. Rows and columns are both numbered from 0, just like 1D array indices.

Row 0 is Ana’s scores, row 1 is Ben’s, and row 2 is Cy’s. Column 2 holds everyone’s score on the third quiz: 77, 81, and 89.

The second picture shows how Java actually stores it. The variable refers to one outer array with three elements, and each of those elements refers to a row array:

scores --> outer array
           index 0 --> [ 90 | 85 | 77 | 92  ]
           index 1 --> [ 68 | 74 | 81 | 88  ]
           index 2 --> [ 95 | 91 | 89 | 100 ]

The grid picture is the one you will use most when reading code. The array-of-arrays picture explains why the rules in the rest of this chapter work the way they do, so keep both in mind.

Declaring and filling a 2D array

The type of a 2D array has two pairs of square brackets. int[] means “array of int,” so int[][] means “array of int[],” an array of arrays of int. The fastest way to create a small 2D array is with an initializer list, just as in Topic 4.3. The difference is that each element of the outer list is itself an initializer list for one row.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };

A 2D array can hold object references as well as primitives. Change one thing, the element type, and the same pattern builds a seating chart of names:

String[][] seats = { {"Ana", "Ben", "Cy"},
                     {"Dee", "Eli", "Fay"} };

The type is String[][], an array of String[] rows. There are two inner lists, so 2 rows, and each holds three names, so 3 columns. Row 1, column 0 is "Dee": count rows from 0 (row 0 is the first line, row 1 the second), then count across from 0. Each box holds a reference to a String object, exactly as the boxes of a String[] did in Topic 4.3.

Every row in these examples has the same number of elements, so the grid is a rectangle. That is always the case in this course. (Java can build a grid whose rows have different lengths, but such grids are outside AP CSA, and you will not see them on the exam.)

public class WrongDimensions
{
    public static void main(String[] args)
    {
        int[] scores = { {90, 85, 77, 92}, {68, 74, 81, 88} };
        System.out.println(scores[0]);
    }
}

WrongDimensions.java:5: error: illegal initializer for int
        int[] scores = { {90, 85, 77, 92}, {68, 74, 81, 88} };
                         ^

The teacher now wants Ben’s score on the third quiz. In a 1D array, one index picks one box. In a grid, one number is not enough: you have to say which row and which column. Think of a seat in a theater, which needs both a row and a seat number. “Seat 5” alone could be any of a dozen seats.

Java uses two pairs of square brackets, one index in each. The first index is the row index and the second is the column index:

scores[row][col]

The order is always row first, column second. The array-of-arrays picture shows why this works with no new rules. scores[1] follows index 1 of the outer array to Ben’s row, which is an ordinary 1D array. Then [2] picks index 2 of that row, just like any 1D array access from Topic 4.3. So scores[1][2] is really two 1D accesses in a row, read left to right.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
System.out.println(scores[1][2]);
System.out.println(scores[2][0]);
System.out.println(scores[0][3]);

81
95
92

scores[r][c] is a variable, not just a value. Anywhere you could put a plain int variable, you can put scores[r][c]: on the left of = to store a new value, with compound assignment such as += (Topic 1.6), or on the right side of an expression. This next example changes three elements.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
scores[0][2] = 80;
scores[1][1] += 6;
scores[2][3] = scores[2][3] - scores[0][2];
System.out.println(scores[0][2]);
System.out.println(scores[1][1]);
System.out.println(scores[2][3]);

80
80
20

• Line 4 stores 80 in row 0, column 2. Ana’s 77 is gone, replaced the same way any assignment replaces a value.
• Line 5 means scores[1][1] = scores[1][1] + 6. Ben’s 74 becomes 80.
• Line 6 evaluates the right side first: scores[2][3] is 100 and scores[0][2] is now 80 (line 4 already changed it), so the result is 20, stored back in row 2, column 3.

Only the three named boxes change. Every other element keeps its value.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
System.out.println("Cy, quiz 1: " + scores[1][2]);

Cy, quiz 1: 81

int[][] tiles = { {4, 7, 2},
                  {9, 5, 8} };
tiles[1][0] = tiles[0][1] + tiles[1][2];
tiles[0][2] *= 3;
System.out.println(tiles[1][0]);
System.out.println(tiles[0][2]);
System.out.println(tiles[1][1] - tiles[0][0]);

15
6
1

An initializer list is handy when you already know every value. Often you do not. A theater that sells tickets needs a chart of 2 rows and 3 seats per row, with every seat starting out empty, and the program will fill seats in as people buy them. For that you need to create the grid at its full size first and put values in later.

In Topic 4.3 you created an empty 1D array with new int[5]. A 2D array uses the same keyword with two sizes:

boolean[][] taken = new boolean[2][3];

Java builds an outer array with 2 elements and gives it 2 row arrays of 3 elements each. Nobody has stored anything in those 6 boxes yet, but Java never leaves an element unset. When new creates a 2D array, every element starts with the default value for its type, the same defaults you met with 1D arrays:

Java fills in defaults so that reading an element you have not yet assigned always gives a predictable answer instead of leftover garbage from memory.

int[][] counts = new int[2][3];
double[][] prices = new double[2][2];
boolean[][] taken = new boolean[3][4];
String[][] names = new String[2][5];
System.out.println(counts[1][2]);
System.out.println(prices[0][1]);
System.out.println(taken[2][3]);
System.out.println(names[0][4]);

0
0.0
false
null

The sizes inside the brackets do not have to be literal numbers. Any int expression works, so a program can use variables. Here the theater stores its seat chart and sells two seats:

int rows = 2;
int seatsPerRow = 3;
boolean[][] taken = new boolean[rows][seatsPerRow];
taken[0][1] = true;
taken[1][2] = true;
System.out.println(taken[0][1]);
System.out.println(taken[0][2]);
System.out.println(taken[1][2]);

true
false
true

Line 3 creates a 2-by-3 grid because rows is 2 and seatsPerRow is 3. All six seats start false, meaning not taken. Lines 4 and 5 store true in two of them. Line 7 reads a seat that was never assigned, so it still holds its default, false.

Once the grid exists, its size cannot change. There is no statement that adds a row or makes the rows longer. This comes straight from 1D arrays: the outer array and every row are ordinary arrays, and an array’s length is set when it is created. If the theater adds a row, the program must create a new, larger 2D array.

public class NullSeat
{
    public static void main(String[] args)
    {
        String[][] seats = new String[2][3];
        seats[0][0] = "Ana";
        System.out.println(seats[0][0].length());
        System.out.println(seats[0][1].length());
    }
}

3
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because ... is null

public class NullSeatFixed
{
    public static void main(String[] args)
    {
        String[][] seats = new String[2][3];
        seats[0][0] = "Ana";
        System.out.println(seats[0][0].length());
        if (seats[0][1] != null)
        {
            System.out.println(seats[0][1].length());
        }
        else
        {
            System.out.println("Seat is empty");
        }
    }
}

3
Seat is empty

boolean[][] lights = new boolean[2][2];
lights[0][1] = true;
System.out.println(lights[1][1]);

double[][] fees = new double[3][2];
fees[2][1] = 12.5;
fees[0][0] = fees[2][1] * 2;
System.out.println(fees[0][0]);
System.out.println(fees[1][1]);
System.out.println(fees[2][1] + fees[2][0]);

25.0
0.0
12.5

Suppose a method already exists that works on one student’s scores, an int[], the kind of method you could have written in Topic 4.4. Can you hand it Ana’s row from the 2D table, or do you have to copy her four scores into a new array first?

Look at the array-of-arrays picture again. Each element of the outer array is a 1D array. So using the 2D array’s name with only one pair of brackets, scores[1], gives you the element at index 1 of the outer array: Ben’s whole row. Its type is int[], and you can use it anywhere an int[] is allowed.

Each pair of brackets peels off one level: from grid to row, then from row to a single number.

There is one more thing to remember from Topic 1.13 and Topic 4.3: arrays are objects, and a variable of an array type holds a reference. scores[1] does not make a copy of Ben’s row. It gives you a reference to the very row that lives inside the grid. If you store it in a variable, that variable and the grid share the row.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
int[] cyRow = scores[2];
System.out.println(cyRow[1]);
System.out.println(cyRow.length);
cyRow[0] = 99;
System.out.println(scores[2][0]);

91
4
99

scores --> outer array
           index 0 --> [ 90 | 85 | 77 | 92  ]
           index 1 --> [ 68 | 74 | 81 | 88  ]
           index 2 --> [ 99 | 91 | 89 | 100 ]  <-- cyRow

The real payoff is passing a row to a method. The method firstAndLast below has an int[] parameter. It has no idea that its argument came from a 2D array.

public class RowToMethod
{
    public static String firstAndLast(int[] quizzes)
    {
        return quizzes[0] + " to " + quizzes[quizzes.length - 1];
    }

    public static void main(String[] args)
    {
        int[][] scores = { {90, 85, 77, 92},
                           {68, 74, 81, 88},
                           {95, 91, 89, 100} };
        System.out.println("Ana: " + firstAndLast(scores[0]));
        System.out.println("Ben: " + firstAndLast(scores[1]));
    }
}

Ana: 90 to 92
Ben: 68 to 88

On line 13, the argument scores[0] is Ana’s row, so the parameter quizzes gets a reference to that row (Topic 3.6). Inside the method, quizzes.length is 4, so quizzes[quizzes.length - 1] is quizzes[3], the last score, 92. Line 14 passes Ben’s row instead, and the same method reports 68 and 88. One method written for 1D arrays now works on any row.

public class RowWrongType
{
    public static void main(String[] args)
    {
        int[][] scores = { {90, 85, 77, 92},
                           {68, 74, 81, 88},
                           {95, 91, 89, 100} };
        int benRow = scores[1];
        System.out.println(benRow);
    }
}

RowWrongType.java:8: error: incompatible types: int[] cannot be converted to int
        int benRow = scores[1];
                           ^

int[][] stock = { {5, 0, 3},
                  {2, 8, 6} };
int[] top = stock[0];
top[1] = 4;
stock[0][2] += top[0];
System.out.println(stock[0][1]);
System.out.println(top[2]);
System.out.println(stock[1].length);

4
8
3

A method that receives a 2D array often has no idea how big it is. The quiz table might have 3 students or 30. To reach the last student’s last score, or just to avoid using an index that does not exist, code needs to ask the grid for its size.

A 1D array tells you its size through length (Topic 4.3). A 2D array has no separate “rows” or “columns” attribute; it does not need one, because the array-of-arrays picture gives both numbers:

• The outer array has one element per row, so scores.length is the number of rows.
• Each row is a 1D array whose length is the number of columns, so scores[0].length is the number of columns.

Row 0 is used because it is always there, and in this course every row has the same length, so any row would give the same answer.

The same counts give the valid indices. Like any array, indices run from 0 up to one less than the length:

An index outside these ranges throws an ArrayIndexOutOfBoundsException, the same exception as a bad index in a 1D array, and for the same reason: one of the two 1D accesses inside grid[r][c] asked for a box that does not exist.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
int lastRow = scores.length - 1;
int lastCol = scores[0].length - 1;
System.out.println(scores.length);
System.out.println(scores[0].length);
System.out.println(scores[lastRow][lastCol]);

3
4
100

Now change the shape. This grid, made with new, has more rows than columns.

int[][] board = new int[5][2];
board[board.length - 1][board[0].length - 1] = 7;
System.out.println(board.length);
System.out.println(board[0].length);
System.out.println(board[4][1]);

5
2
7

new int[5][2] makes 5 rows of 2 columns, so board.length is 5 and board[0].length is 2. Line 2 stores 7 at board[4][1], the bottom-right box: row index 4 (5 − 1) and column index 1 (2 − 1). When a grid is not square, mixing up the two lengths gives a different answer, which the next Watch Out shows.

int[][] scores = { {90, 85, 77, 92},
                   {68, 74, 81, 88},
                   {95, 91, 89, 100} };
System.out.println("Ana's last quiz: " + scores[0][scores.length - 1]);

Ana's last quiz: 77

public class PastLastColumn
{
    public static void main(String[] args)
    {
        int[][] scores = { {90, 85, 77, 92},
                           {68, 74, 81, 88},
                           {95, 91, 89, 100} };
        System.out.println("Ben's last quiz:");
        System.out.println(scores[1][scores[0].length]);
    }
}

Ben's last quiz:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4

int[][] marks = new int[2][5];
marks[marks.length - 1][0] = marks[0].length;
marks[0][marks[0].length - 1] = marks.length * 10;
System.out.println(marks[1][0]);
System.out.println(marks[0][4]);
System.out.println(marks[1][4]);

5
20
0

This program runs a small ticket booth. It creates a seat chart with new, fills seats using indices, uses length to find the last row and column, changes a seat through a row variable, and checks for an empty seat before treating it as a name.

public class TicketBooth
{
    public static void main(String[] args)
    {
        String[][] seats = new String[3][4];
        seats[0][0] = "Ana";
        seats[1][3] = "Ben";
        seats[seats.length - 1][0] = "Cy";
        String[] middle = seats[1];
        middle[1] = "Dee";
        System.out.println("Rows: " + seats.length);
        System.out.println("Seats per row: " + seats[0].length);
        System.out.println("Row 1, seat 1: " + seats[1][1]);
        System.out.println("Row 2, seat 0: " + seats[2][0]);
        System.out.println("Last seat: " + seats[seats.length - 1][seats[0].length - 1]);
        if (seats[0][2] == null)
        {
            System.out.println("Row 0, seat 2 is open");
        }
    }
}

The chart has 3 rows and 4 seats per row, and every box starts as null.

Rows: 3
Seats per row: 4
Row 1, seat 1: Dee
Row 2, seat 0: Cy
Last seat: null
Row 0, seat 2 is open

Line 15 prints the word null by joining it to a string, which is safe; only calling a method on null would crash. Line 16 avoids that kind of crash by comparing with null before using the seat.

Each of these mistakes was taught in its own subsection. This table lets you look up a message you see when your own code goes wrong.

• A 2D array is an array of arrays: an outer array whose elements are 1D row arrays of the same type. Picture it as a grid of rows and columns, both numbered from 0. It can hold primitives or object references, and in this course every row has the same length.
• Create a 2D array with an initializer list of row lists, such as { {1, 2, 3}, {4, 5, 6} }, or with new type[rows][cols], which fills every element with its default value: 0, 0.0, false, or null. The size cannot change after creation.
• grid[r][c] reads or changes one element. The first index is always the row and the second is always the column.
• grid[r], with one pair of brackets, is row r as a 1D array. It is the same row object as the one inside the grid, so changes made through it show up in the grid.
• grid.length is the number of rows and grid[0].length is the number of columns. Indices outside 0 to length − 1 throw an ArrayIndexOutOfBoundsException.

int[][] grid = { {3, 1, 4, 1},
                 {5, 9, 2, 7} };
int[] second = grid[1];
grid[0][grid.length] = second[3];
second[0] -= grid[0][0];
System.out.println(grid[0][2]);
System.out.println(grid[1][0]);
System.out.println(grid.length + grid[1].length);

7
2
6

public class BottomRight
{
    public static void main(String[] args)
    {
        double[][] temps = { {61.5, 70.0, 66.5},
                             {58.0, 73.5, 69.0} };
        System.out.println("Last reading:");
        System.out.println(temps[temps.length][temps[0].length]);
    }
}

System.out.println(temps[temps.length - 1][temps[0].length - 1]);

int[][] nums = { {2, 4},
                 {6, 8},
                 {10, 12} };
System.out.println(nums[2][1] + nums.length * nums[0].length);

public class AttendanceChart
{
    public static void main(String[] args)
    {
        // 3 school days (rows) by 4 class periods (columns)
        int[][] absences = new int[4][3];
        absences[0][1] = 2;
        absences[2][3] = 1;
        System.out.println(absences[0][1] + absences[2][3]);
    }
}

int[][] absences = new int[3][4];

• I can explain why a 2D array is called an array of arrays and draw one as a grid of rows and columns. Reread
• I can read a 2D initializer list and say how many rows and columns it creates. Reread
• I can read and change one element with two indices, row first and column second. Reread
• I can create a 2D array with new and say what default value every element starts with. Reread
• I can use one pair of brackets to get a row and explain why changing that row changes the grid. Reread
• I can find the number of rows and columns with length and name every valid index. Reread