Section 7.3 Arrays and References
There are two items to consider when working with arrays and reference types. The first is that array variables are reference types and follow all the same rules as object reference types. The second is that array elements that store objects are reference types as well, and so they store only a reference to the object, not the object itself.
Subsection 7.3.1 Array Variables as Reference Types
As a reference type, an array variable is just a name that references an array. There is nothing to stop us from declaring a second array variable and assigning it to the same array, giving us two names for the array. As we know, assigning one reference variable to another does not copy the object being referenced. Rather, the value of the second reference variable gets the address of the object referenced by the first variable. This is why both variables reference the same object. Using either variable, when we access and modify an array element, the single underlying array is being modified. Specifically, we can modify an array referenced using one variable, and see the modification when accessing it using the other array variable. Let’s run some tests.
jshell> String[] names = {"Athos", "Porthos", "Aramis"};
names ==> String[3] { "Athos", "Porthos", "Aramis" }
jshell> String[] musketeers = names;
musketeers ==> String[3] { "Athos", "Porthos", "Aramis" }
jshell> musketeers[2] = "d'Artagnan" // Modify third element of second var
$3 ==> "d'Artagnan"
jshell> System.out.println( names[2] ) // Print third element of first var
d'Artagnan
jshell>
As we can see in the previous JShell session, we declared and initialized our
names array with three Strings. We also declared a second String array named musketeersand assigned it to the name of the first array. At this point both array variables names and musketeers reference the same underlying array. We demonstrate this by changing the content of the last item in the names array and then print the last item in the mustketeers array. The change made using the names array variable is seen using the musketeers array variable, because both variables reference the same underlying array.Subsection 7.3.2 Array Elements as Reference Types
If we declare an array of a primitive type, the elements of the array hold actual primitive values, not references. For example, if we declare a double array, even without initializing the elements, the values held in the array element are set to the default numeric double value of 0.0.
jshell> double[] data = new double[5];
data ==> double[5] { 0.0, 0.0, 0.0, 0.0, 0.0 }
jshell> for (int i=0; i<data.length; i++) {
...> System.out.println( data[i] );
...> }
0.0
0.0
0.0
0.0
0.0
jshell>
The
data double array above holds five double values. But what about a String array? How many String objects exist after we declare a String array with length 3? Are there three empty String objects with value "", or maybe something else? See the following JShell session.jshell> String[] names = new String[3];
names ==> String[3] { null, null, null }
jshell>
After declaration of the String array variable and creation of the String array, JShell prints the array for us. We see that the three elements of the String array are
null, null, null. Recall that the null keyword signals the absence of an object. The names array contains no objects, whatsoever. True, it has the ability to reference three String objects should we create and assign them, but unless the array elements are initialized, we have completed only two of the three steps required for fully creating and populating an array: the array is created, but its elements have not been initialized.An array of some reference type has elements that themselves reference external objects. Array elements do not hold objects, they reference them. In this regard, the elements of the array themselves follow the reference type rules.
In the following JShell session we create and initialize an array of two StringBuilder objects named
sbs1. Then we create a second StringBuilder array named sbs2 and assign it to the first. We append Strings to both StringBuilders by accessing them using the elements of sbs1, and then print the entire array sbs2. We see that both StringBuilder objects as viewed through sbs2 hold the Strings appended to the StringBuilders accessed using sbs1. The same reference variable rules apply to array elements if they too are reference types.jshell> StringBuilder[] sbs1 = {new StringBuilder(), new StringBuilder()};
sbs1 ==> StringBuilder[2] { , }
jshell> StringBuilder[] sbs2 = sbs1;
sbs2 ==> StringBuilder[2] { , }
jshell> sbs1[0].append( "I am the first one" );
$3 ==> I am the first one
jshell> sbs1[1].append( "I am the second one" );
$4 ==> I am the second one
jshell> sbs2
sbs2 ==> StringBuilder[2] { I am the first one, I am the second one }
jshell>
Subsection 7.3.3 Arrays as Method Parameters
If a reference type is passed to a method as an argument, the method parameter gets a copy of the reference, not a copy of the entire object. Passing reference types to methods as arguments is equivalent to assigning the method parameter variables to the argument values passed. Consequently, a reference is passed to the method, not a copy of the argument. As a reference type, an array passed to a method actually passes only the array reference, not the entire array. This behavior allows us to write methods that receive and operate on arrays without the need to copy the entire array. For large arrays, this can be far more efficient than copying all the array elements and then possibly copying all the modified elements back to the original array.
The program in Listing 7.3.1 defines three static methods. In addition to the
main(…) method you will find the printArr( double[] arr ) method and the doubleArr( double[] arr ). Both methods take a double array parameter. The printArr(…) method iterates over all elements of the array and prints each. The doubleArr(…) method multiplies all elements by 2 and reassigns each updated value back to the array element.// ArrayArgs.java
public class ArrayArgs {
public static void main(String[] args) {
// Create array
double[] nums = {1.2, 2.3, 3.4, 4.5 };
printArr( nums ); // Print array
doubleArr( nums ); // Double array elements
printArr( nums ); // Print array
}
// Print all elements of the array arr
public static void printArr( double[] arr ) {
for (double x : arr) {
System.out.print(x + " ");
}
System.out.println();
}
// Double all array elements
public static void doubleArr( double[] arr ) {
for (int i=0; i<arr.length; i++) {
arr[i] *= 2;
}
}
}
ArrayArgs.javaCompiling and running the program in Listing 7.3.1 produces the following output. Note that both methods have
void return types; nothing is returned from either method. In spite of this, the doubleArr(…) method modifies the elements of the original array, which is demonstrated when the array is printed a second time and we see that all element values have been doubled. As we know, the reason that the original array elements are modified by doubleArr(…) is because a reference to the orignal array is passed to the method, not a copy. Consequently, the original array elements are modified.javac ArrayArgs.java java ArrayArgs 1.2 2.3 3.4 4.5 2.4 4.6 6.8 9.0
Subsection 7.3.4 Passing Arguments on the Command-line
We now know what the signature of the
main(…) method actually means. The String[] args is an array of String objects, which is passed to the method when your program starts. Java reads all the items on the java launcher command-line that follow the class name, and passes them to main(…) in the args String array. Study Listing 7.3.2 and the console session that follows.// CommandLine.java
public class CommandLine {
// The main() method received a String array argument
public static void main(String[] args) {
// What's in the args array?
System.out.println("Received " + args.length + " command-line arguments");
for (String arg : args) {
System.out.println(arg);
}
}
}
CommandLine.javajavac CommandLine.java java CommandLine Hello World Received 2 command-line arguments Hello World
Try running the
CommandLine.java program yourself with your own arguments. In addition to using the Scanner object to prompt the user for input, passing arguments on the command-line is a way to pass data into your program on startup.
