Imagine a class of 7 students that have a quiz every week for 5 weeks. The instructor records the grades in a table. A particular cell of the table is designated by student number and week number. For example:

• The grade for student 0 week 1 is 42
• The grade for student 3 week 4 is 93
• The grade for student 6 week 2 is 78

To specifying a cell use row and column indexes like this:

gradeTable[ row ][ col ]

As with one dimensional arrays, indices start at zero. For example:

• gradeTable[ 0 ][ 1 ] is 42
• gradeTable[ 3 ][ 4 ] is 93
• gradeTable[ 6 ][ 2 ] is 78

In Java, a table may be implemented as a 2D array. Each cell of the array is a variable that can hold a value and works like any variable. As with one dimensional arrays, every cell in a 2D array is of the same type. The type can be a primitive type or an object reference type.

Say that gradeTable is a 2D array of int, and that (conceptually) it looks like the table to the right. Then,

The subscripted variables are used in assignment statements and arithmetic expressions just like any variable:

The row and column numbers are not part of the array. They are usually shown in pictures of an array, but the array object does not explicitly contain the indexes. When you ask for

Java knows what cell you mean and goes there directly.

More Important Stuff:

• Rows are numbered from 0 to N-1, where N is the number of rows
• Columns are numbered from 0 to M-1, where M is the number of columns.
• A 2D array with N rows and M columns per row will have N times M number of cells.
• However, it is possible for a 2D array to have a different number of cells in each row.

Details about these issues will follow.

When your program is running and it tries to access an element of an array, the Java virtual machine checks that the array element actually exists. This is called bounds checking. If your program tries to access an array element that does not exist, the Java virtual machine will generate an:

Ordinarily, this will halt your program. Of course, as with 1D arrays, array indexes must be an integer type.

It makes no sense to access gradeTable[ 3.5 ][ 2 ].

As with a 1D array, an array index may be an integer literal, a variable of integer type, a method that evaluates to an integer, or an arithmetic expression involving all of these things:

We are not likely to need a statement as complicated as the last one.

The following program creates a 2D array of int that implements the gradeTable example. Details about declaring and constructing 2D arrays will be explained later.

The declaration of gradeTable uses an initializer list as a short-cut way to create a 2D array object and place values into it. The list contains 7 rows each separated by a comma; each row is a list of values.

class gradeExample
{
  public static void main( String[] arg )
  {
    // declare and construct a 2D array
    int[][] gradeTable = 
        {  {99, 42, 74, 83, 100}, 
           {90, 91, 72, 88, 95},
           {88, 61, 74, 89, 96},
           {61, 89, 82, 98, 93},
           {93, 73, 75, 78, 99},
           {50, 65, 92, 87, 94},
           {43, 98, 78, 56, 99}  };

    System.out.println("grade 0,0: " + gradeTable[0][0]);
    System.out.println("grade 2,4: " + gradeTable[2][4]);

    gradeTable[5][3] = 99 ;

    int sum = gradeTable[0][1] + gradeTable[0][2] ;
    System.out.println( "sum: " + sum );
  }
}

Question 6:
What does the program print out?

Two-dimensional arrays are objects. A variable such as gradeTable is a reference to a 2D array object. The declaration

says that myArray is expected to hold a reference to a 2D array of int. Without any further initialization, myArray starts out holding null. The declaration

says that myArray can hold a reference to a 2D array of int, creates an array object of 3 rows and 5 columns, and puts the reference in myArray. All the cells of the array are initialized to zero. The declaration

does exactly the same thing as the previous declaration (and would not ordinarily be used.) The declaration

creates an array of 3 rows and 5 columns and initializes the cells to specific values.

Question 7:
After the last statement, what is the value myArray[1][2] ?

Each row of a 2D array may have a different number of cells. In the example, the array uneven has

• 3 cells in its first row,
• 2 in its second row,
• and 5 in its last row.

If a program refers to a cell that does not exist, bounds checking will catch the error (as the program runs) and generate an exception (which usually will halt your program.)

Notice that row 1 in the above has only two cells. (It is incorrect to think that row 1 has more cells but that only the first two are initialized.) Making an assignment to a cell that does not exist is an error.

The length of a 2D array is the number of rows it has. The row index runs from 0 to length-1.

Each row of a 2D array can have a different number of cells, so each row has its own length:

uneven[0] refers to row 0 of the array, uneven[1] refers to row 1, and so on.

The following answer will not work:

An initializer list can only be used to initialize an array, not to assign values to it after it already exists.

Perhaps your answer was:

This will work, but does not quite do what the question asked. The suggested answer puts the values into the required cells of the existing 1D array object of row 0.

The not-quite-right answer replaces the old row 0 with a new row. It constructs a new 1D array object that holds the desired values in its cells, then assigns that object to row 0 of myArray. The previous row 0 is now garbage.

Both answers result in myArray containing what you want. In most programs it will not matter which method you used.

Usually you think of a 2D array as a table, not the complicated structure of the previous page. For example,

int[][] uneven = 
    { { 1, 9, 4 },
      { 0, 2},
      { 0, 1, 2, 3, 4 } };

is usually thought of as like the table on the right. Only occasionally do you have to think of "arrays of references to 1D arrays."

Now consider how you would print out every element contained in array uneven.

Here is a program that creates a 2D array, then prints it out.

The nested loops are written to print out the correct number of cells for each row. The expression uneven[row].length evaluates to a different integer for each row of the array.

class unevenExample3
{
  public static void main( String[] arg )
  {
    // declare and construct a 2D array
    int[][] uneven = 
        { { 1, 9, 4 },
          { 0, 2},
          { 0, 1, 2, 3, 4 } };

    // print out the array
    for ( int row=0; row < uneven.length; row++ )
    {
      System.out.print("Row " + row + ": ");
      for ( int col=0; col < uneven[row].length; col++ )
        System.out.print( uneven[row][col] + " ");
      System.out.println();
    }

  }
}

Question 14:
For the print method to work, must every row of uneven be non-null?

Question 15:
(Thought Question: ) Are 3-dimensional arrays possible?