A Java array stores in memory a sequence of data items having a common data type. The entire sequence can be assigned to a single variable with each element accessed using the variable name followed by a sequential integer index (offset) in square brackets, starting with 0. Arrays are incredibly useful when you must store a very large number of related values.
Using an integer index for element access works well with iteration counters, very much like the way we access elements in an ArrayList using the get(…) method. Arrays are similar to an ArrayList collection class in some aspects, but significantly different in others. We’ll compare and contrast the two as we learn more about Java arrays.
Subsection7.1.1Declaring Arrays
An array variable is declared just like any Java variable, using a data type. In fact, an array can be declared to hold any Java data type, primitive, object, or even another array. Contrast this with an ArrayList which must box primitives before one can be added to the ArrayList. The core difference between an array and the type that it holds is that the declaration of an array follows the type of elements it holds with a pair of square brackets ([]).
In the JShell session below, we declare a doublearray variable just like we would declare a double variable, only we follow the type with []. It’s useful to read this declaration as double-array data. The variable data may now reference an array that holds doubles. Note that the array has not yet been created. We’ve only declared a variable that may reference an array at some point.
jshell> double[] data;
data ==> null
jshell>
We also see that the data array variable starts with the value of null. This is very important to note. In Java, array variables are reference variables, just like variables with a class type are reference variables. The variable itself is not the array, which is demonstrated by its initial default value being null. As a reference variable, all the same rules and behaviors that we investigated in Chapter 4 apply eually to array variables.
We can declare an array of any valid type in Java, including primitive types. In fact, we can declare arrays of arrays, which we will investigate further in Section 7.4. The following code snippet illustrates the idea that an array can hold any Java type. None of the following variables are arrays. They are only variables that may reference an array, not the array itself.
double[] data; // An array variable of doubles
int[] lengths; // An array variable of integers
String[] names; // An array variable of Strings
Random[] rands; // An array variable of Random objects
Subsection7.1.2Creating Arrays
Similar to instantiating new objects using a constructor, the syntax for creating a new array makes use of the new keyword. This reinforces the fact that arrays are reference types. Unlike invoking an object constructor, the syntax for creating a new array follows the new keyword with the data type to be stored in elements of the array and then square backets containing the number of elements to be stored in the array. Unlike ArrayLists, arrays are fixed-size. When an array is created using the new keyword, the amount of memory allocated is the number of bytes required for a single type multiplied by the size of the array.
In the following code snippet, we create and assign arrays of size 100 for each of the array variables declared above.
data = new double[100];
lengths = new int[100];
names = new String[100];
rands = new Random[100];
Note that we also can use the combination declaration/initialization statement just like we did with single-valued variables. See the following.
double[] data = new double[100];
int[] lengths = new int[100];
String[] names = new String[100];
Random[] rands = new Random[100];
Subsection7.1.3Accessing Array Elements
Once created, you may access and use the elements of an array just like you would a single-valued variable. The only difference is that you must follow your array variable with square brackets and an item index so that Java knows which element of the array you want to access. In general, working with array variables is very similar to working with a single data variable, only with the addition of square brackets and an index.
In the example below, the data array variable is declared and initialized to a new array of doubles with length 100. These items are then accessed by following the array variable name data with square brackets and an index, for example data[0].
jshell> double[] data = new double[100];
data ==> double[100] { 0.0, 0.0, 0.0, 0.0, 0.0, ... 0.0, 0.0, 0.0, 0.0, 0.0 }
jshell> System.out.println( data[0] ); // Access an array for printing
0.0
jshell> data[0] = 3.14; // Assign a value to an array element
$3 ==> 3.14
jshell> System.out.println( data[0] );
3.14
jshell>
Rule: Sequence Data Structure Indexes Start at 0.
In Java, we learned that when accessing an indexed sequence of items, the index of the first item always starts at 0. This is the case for arrays as well. Think of an index as an offset from the start of a sequence, not as an item’s sequence position. The offset from the first element to the first element is 0, hence the index of the first element is 0.
The idea that array is a sequence of data values is more than just a useful metaphor. Array elements are stored in contiguous memory, one after the other.
In the data array example of Figure 7.1.1, note that Java initializes all double array items with the value 0.0, just like it would initialize a single-valued double variable. This is the case with any array holding any numerical type.
If numeric array elements are initialized with a value of 0, how about boolean array elements? What is the default value assigned to a single boolean variable? As always, JShell is a useful tool to investigate Java’s behavior.
In both cases the default value of a boolean is false. Java sets the initial value of array elements to the same initial value that it would set to a single-valued variable.
Subsection7.1.4Initializing Arrays
Just like we can initialize a variable at the time of declaration, we also can initialize the elements of an array. We must specify multiple element values for the array to be initialized, one for each array element. Syntactically, we follow the creation of the array with a sequence of values delimited with braces ({…}) and separated by commas. In the following example we declare the double array variable data, assign it to a newly created double array, and initialize the double array to the values 10.0, 20.0, 30.0, 40.0 and 50.0.
double[] data = new double[] {10.0, 20.0, 30.0, 40.0, 50.0};
Did you see that we left out the size of the array between the square brackets when we created the array using new? Including a size value would open us up to an inconsistency. What should happen if we declared the size of the array to 5, but we provided on 4 values, or 6? To avoid the issue, when initializing the elements of an array using this syntax, Java allows us to create the array without a size; it can infer the correct size from the number of items it finds between the braces.
We can shorten the above example even further. The new double[] part of the expression is redundant. Clearly, we want to create a new double array because we declared the variable as type double[] and we provided initial element values within the initializer ({…}). There are legitimate reasons to declare an array variable without creating an array, but no legitimate reason if initial array values are provided. For this reason Java let’s us accomplish the same task of creating and initializing the array without the need to include the new double[] part. In the example below, we create and initialize the array by going right to the initializer in curly braces, leaving out the redundant new double[].
double[] data = {10.0, 20.0, 30.0, 40.0, 50.0};
This initialization syntax may be used with any type, provided you are able to write down the sequence of values in braces. In the examples below, pay careful attention to the rands array holding two Random objects. The only means of creating Random objects is to use the Random constructor. Within the braces of the initializer, we invoked the Random constructor twice to create two objects which are stored in the rands array.
Take a moment to note something important about arrays. In order to fully realize an array containing non-default element values, you must complete three steps.
There must be a variable that references the array. Without maintaining a reachable reference, the array is subject to garbage collection.
Declaring an array variable does not create an array. You must use the new keyword and follow the array declaration syntax with size in square brackets (or initializing values) to create the actual array. The variable has the ability to reference an existing array only, not to create the array. You must explicitly create the array in order for it to exist.
A newly created array contains elements with default values for its type. A third step of initializing the array is required for it to contain something other than default values.
