Often the data a program uses comes from a two dimensional situation. For example, maps are two-dimensional (or more), the layout of a printed page is two-dimensional, a computer-generated image (such as on your computer's screen) is two dimensional, and so on.

For these situations, a Java programmer can use a two-dimensional array. This allows for the creation of table-like data structures with a row and column format. The first subscript will define a row of a table with the second subscript defining a column of a table. Here is an example program including a diagram of the array.

Program 21-1

class ArrayExample
{
  public static void main (String[] args)
  {
    int[][] table = new int[3][4];
    int  row, col;

    for (row = 0; row < 3; row++)
      for (col = 0; col < 4; col++)
        table[row][col] = row + col;
  }
}

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

int[][] table;

says that table can hold a reference to a 2D array of integers. Without any further initialization, it will start out holding null.

The declaration

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

says that table can hold a reference to a 2D array of integers, creates an array object of 3 rows and 4 columns, and puts the reference in table. All the elements of the array are initialized to zero.

The declaration

int[][] table = { {0,0,0,0},
                  {0,0,0,0},
                  {0,0,0,0} };

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

The declaration

int[][]table = { {0,1,2,3},
                 {1,2,3,4},
                 {2,3,4,5} };

creates an array of the same dimensions (same number of rows and columns) as the previous array and initializes the elements to the same values in each cell.

If no initializer is provided for an array, then when the array is created it is automatically filled with the appropriate value: zero for numbers, false for boolean, and null for objects.

Just as with one-dimensional arrays, the row and column numbering of a 2-D array begin at subscript location zero (0). The 3 rows of the table are referenced from rows 0...2. Likewise, the 4 columns of the table are referenced from columns 0...3.

This particular two-dimensional array table is filled with the sums of row and col, which is accomplished by Program 21-2. To access each location of the matrix, specify the row coordinate first, then the column:

table[row][col]

Each subscript must have its own square brackets.

The length of a 2D array is the number of rows it has. The row index will run from 0 to length-1. The number of rows in table are given by the value table.length.

Each row of a 2D array has its own length. To get the number of columns in table, use any of the following:

table[0].length
table[1].length 
table[2].length

There is actually no rule that says that all the rows of an array must have the same length, and some advanced applications of arrays use varying-sized rows. But if you use the new operator to create an array in the manner described above, you'll always get an array with equal-sized rows.

The routine that assigned values to the array used the specific numbers of rows and columns. That is fine for this particular program, but a better definition would work for an array of any two dimensions.

Program 21-2

class ArrayExample2
{
  public static void main (String[] args)
  {
    int[][] table = new int[3][4];
    int row, col;

    for (row = 0; row < table.length; row++)
      for (col = 0; col < table[row].length; col++)
        table[row][col] = row + col;
  }
}

In Program 21-2, the limits of the for loops have been redefined using table.length and table[row].length so that they work with any two-dimensional array of ints with any number of rows and columns.