Array Basics and Indexing

Many programs must track many items at once. Consider a program that draws the same message 25 times on the screen. Each copy appears at its own location, in its own color and font, and each one drifts across the window at its own speed. Every copy therefore needs a set of facts: where it is, how fast it moves horizontally and vertically, what color it has, and which font it uses. The question this article answers is how a program should organize those facts so that all 25 copies can be tracked at the same time.

A related problem appears even in a simpler setting. Suppose a program must process the names of one thousand people. The natural first thought is to create one thousand variables to hold the names and one thousand print statements to display them. That approach becomes unworkable very quickly. An array solves this problem by keeping the whole list under a single name, and it lets you reach any single item through its position in that list.

Two rules shape arrays in Java. First, every item in the array must be of the same type. Second, the numbering always begins at zero. The source notes that some other programming languages do not impose the same-type rule, so this is a property of the Java setting rather than a property of arrays in general.

Three terms describe any array, and keeping them separate is the key to reading array descriptions correctly. The length is the number of items the array contains. The base type is the type shared by the individual items. The index is the position number of one particular item.

Because positions are numbered from zero, an array of length n has indices that run from 0 to n minus 1. The highest index is always one less than the length. A learner who treats the first position as index 1 has made the most common indexing error, and that error is addressed later in this article.

Read the diagram from left to right. The first name sits at index 0 and the last name sits at index 4. The length is 5 even though the last index is 4. Each slot holds one value of the base type, which here is String.

An array of ints can be understood as a list of variables of type int, and an array of Strings can be understood as a list of variables of type String. The source is explicit that an array is not, properly speaking, just a list of integers or strings. It is better thought of as a collection of variables, each of which can hold a value of the array's base type.

The individual variables that make up an array are called its elements. Each element can hold a value of the base type, and the value of an element can be changed at any time, just as the value of an ordinary variable can be changed. An element is therefore a storage position. The value currently stored in that position is separate from the position itself.

The first idea most programmers reach for is to give each fact its own array. For the 25 copies of the message, the program can declare six arrays, each holding 25 values. One array holds the horizontal coordinates, one holds the vertical coordinates, two hold the velocity components, one holds the colors, and one holds the fonts. The velocity arrays are not needed for drawing at all. They are read later, when the positions are updated for the next frame.

The drawing code reads all of these arrays with one shared index. The string at position i is drawn at the point given by x[i] and y[i], takes its color from color[i], and uses the font stored at font[i]. Nothing in the arrays themselves says that position 2 in x belongs with position 2 in y. The link exists only because the program always uses the same index for each array. This arrangement is called a set of parallel arrays.

The diagram shows only three of the positions, but the pattern continues for every index. Each array is independent in storage. The only thing connecting Cruz, age 20, and score 88 is that all three sit at index 2 in their respective arrays.

Because the connection between arrays is carried only by the index, a single edit to one array can silently break the connection. The following program stores three students in two parallel arrays, names and scores. It then swaps only the names of the first and third students, leaving the scores array untouched.

This is the central debugging lesson of parallel arrays. When a printed result does not match what you expected, look for every statement that writes to any one of the arrays. For each one, ask whether the rest of the set changed with it. If the answer is no, the arrays have drifted out of alignment.

The source program does not keep six separate arrays for the strings. It points out that parallel arrays work in this simple example, but that they go against the object-oriented habit of keeping related data together in one object. If all the data for one copy is stored in one object, the relationship between the values never has to be imagined, because all of it sits in one place. The author therefore defines a small class that holds everything needed to draw one string.

Each object of this class is a complete record for one copy of the message. The fields have the same names as the parallel arrays did, but they now belong to a single item. The program refers to the fields of one object rather than to matching positions in several arrays.

Once the array of objects is filled, the strings can be drawn with an ordinary counting loop, in which each iteration uses the index to pick one object. The source program uses an equivalent for-each loop, which the author describes as easier to understand. The loop control variable named data takes on one element of the array on each pass, in order from the first index to the last.

Because the elements are references to StringData objects, data gives direct access to the fields of that copy. The array index no longer appears in the loop. The loop variable holds the element itself, not a copy of its value, which is why the fields of data can be read directly.