Introduction to Arrays

Most arrays you have met so far can be pictured as one line of boxes. Each box holds one value and is identified by its position in the line. That picture works well for a list of test scores or a sequence of temperatures. Many real problems, however, have information that naturally fits into a grid. A seating chart, a calendar month, a spreadsheet, or a game board all organize their data in rows and columns. A two-dimensional array is the data structure designed for that kind of layout.

Before any of that, this article starts with the basic mechanics of a one-dimensional array, because the same two-step idea applies to every array, including grids. Keep one question in mind as you read: if you were given only a row number and a column number, could you find the one element they point to?

An array type is built from two parts: the base type of the array, followed by a pair of empty square brackets. The base type is the type of each element the array will hold. The brackets mark the type as an array type rather than a single value of the base type. So an array of ints has the type int[], and an array of Strings has the type String[].

Once you have the type, a variable is declared by writing the type, a space, and the variable name, followed by a semicolon. For example, a variable named names that is meant to refer to an array of Strings is declared with the type String[] followed by the name. The declaration tells the compiler what the variable may refer to. The name is what you will later use to reach the array.

The diagram below compares the state of the variable a before and after the creation step. Before creation, the variable has a type but refers to nothing. After creation, the variable refers to one array object that holds five elements. The source gives only this logical structure: one variable, one array, and an indexed set of elements. It does not describe how the elements are stored in memory, so the figure does not show that either.

Creating an array is the step that produces the actual array. In Java this is done with an operator named new. The source notes that arrays in Java are objects and that this special syntax is related to that fact, but the details of object creation are not needed at this stage. What matters is the pattern you write.

The two steps often appear on neighboring lines and mention the same variable name, which makes them easy to confuse. Read them in order. The declaration gives the variable a type. The creation statement supplies the array the variable will refer to. The source states that an array must be created before it is used, so creation must come before any work on the elements.

A two-dimensional array organizes its elements in a rectangular grid made of rows and columns. Each row runs across the grid and holds one element for every column, and each column runs down the grid and holds one element for every row. This layout suits data such as tables and boards, where a position is naturally described by two coordinates rather than one.

A grid is described by its number of rows and its number of columns, usually stated rows first, then columns. A grid with five rows and seven columns is called a 5-by-7 grid. The source does not show the code for creating a two-dimensional array, so this article focuses on how the grid is organized and numbered rather than on that syntax.

The total number of elements in a rectangular grid is found by multiplying the number of rows by the number of columns. Each row contributes one element for every column, so the rows together give the total. A 5-by-7 grid holds 35 elements, which is the example the source uses.

Rows and columns are both numbered starting from 0, so the last index is always one less than the count. An element is identified by its row number followed by its column number, and the pair picks out exactly one cell. The row number always comes first. You can read the pair as a path that moves down the grid to the row and then across to the column.

The same procedure works for any cell, and only the two numbers change. The element at row 0, column 0 is always the top-left cell of the grid. The element at the last row and last column is always the bottom-right cell.

An array variable is declared with an array type, such as int[] or String[], and the declaration only gives the variable a type. The array itself is produced by new, which needs a base type and a length. Once the array exists, a two-dimensional array organizes its elements into rows and columns, and a row and column pair identifies one cell.