Accessing Array Elements by Index

Suppose a program stores a list of names in an array. Sometimes the program needs the whole list, and sometimes it needs just one entry, such as the name in a particular position. How does a program point at one entry without copying the others? This article answers that question for arrays, and it does so by tracing exactly what happens to the array's contents as each statement runs.

An array is one name for one object that holds many values. The variable name, such as namelist, refers to the array as a whole. Individual values inside the array are reached through the same variable name combined with an index number written inside square brackets. Before we reach individual values, though, we need to know how an array gets its values in the first place. Keep one question in mind as you read: at which point in a program is the array being filled, and what does the statement that does the filling allow?

An array holds several elements rather than a single value, so initializing an array variable means supplying those elements at once. One form lists the values, separated by commas, and encloses the whole list between a pair of braces. The list is attached to the declaration itself, so the array variable is created and filled in one statement.

Read this statement as a single action. It names the array, smallPrimes, sets its element type to int, and provides the values that will go into it. The length is not written anywhere in the statement. The source explains that this statement creates an array of int with length 10, filled with the values in the list. The length is determined by counting the items in the braces. If you add or remove a value inside the braces, the length changes with it.

Now let us trace the state of smallPrimes. Counting starts at zero, so the first value sits at index 0 and the last value sits at index length minus 1, which is index 9 here. The diagram shows the ten positions that result from the list, with the value of each position beneath it. Notice that the value 5 sits at index 2, because index 0 holds 2, index 1 holds 3, and index 2 holds 5.

The array has length 10 because the list has ten items, and the highlighted position shows that index 2 is the third slot, holding the value 5. The index is a position number, not the value itself. Reading smallPrimes[2] gives you 5, while the index is 2.

The source describes a second way to initialize an array variable: give it an array created with the new operator. Unlike the braces form, this approach can also be used in assignment statements. You specify the element type and the size, and Java creates an array of that size.

When an array is created this way, all of its elements have their default value. The source does not list those defaults in this passage, but in Java the default for an int element is 0 and the default for a String element is null. So a freshly created nameList holds 100 null references until you store strings into it. Nothing has been assigned yet, but every slot already has a defined default.

Both forms create arrays, but they differ in when the values are known and where the statement can appear. Use the table as a decision aid.

In short: if you already know the values and the array is being declared, the braces list states them directly. If you need an array of a particular size and plan to fill it afterward, or you need to replace an array's contents later in the program, the new operator is the form the source allows in assignment.

The syntax for an element has two parts: the array name, followed by the index in square brackets. In the form array_name[index], the array name identifies which array you mean, and the index identifies which element of that array you mean. The source's example is namelist[7], which refers to the element at index 7 in the array named namelist. Notice that namelist by itself still refers to the array as a whole, while namelist[7] refers to just one piece of it.

The diagram below in the anatomy shows the array name pointing at the whole collection, and the reference namelist[7] pointing at one position inside it. The neighboring positions, index 6 and index 8, are only context; their contents are not part of the reference. The diagram is a picture of the idea, not a claim about how the language stores arrays internally.

Once you have written an element reference, you can treat it as an ordinary variable. You can assign a value to it, print it, or use it in an expression. Reading an element and writing an element use the same notation. The element is not a special kind of thing in these operations; it simply has the array name and index as its name.

An array also carries a value that describes its size. You refer to it by writing the array name, then a period, then the word length. For the array named smallPrimes, the length is written smallPrimes.length, and it reads as 10. The length is determined by the number of items the array holds, and it describes the array rather than one of its contents.