This chapter is from the book
This chapter is from the book
This chapter is from the book
Array Initialization
An array in Java is a type of object that can contain a number of variables. These variables can be referenced only by the array index—a nonnegative integer. The first element in an array has an index of 0.
All of these contained variables, or elements, must be the same type, which is the type of the array. Every array has an associated length variable, established when the array is created, which you can access directly. If you try to address an element with an index that is outside the range of the array, an exception is generated. Java arrays are one dimensional, but an array can contain other arrays, which gives the effect of multiple dimensions.
You can have arrays of any of the Java primitives or reference variables. The important point to remember is that when created, primitive arrays will have default values assigned, but object references will all be null.
Declaration
Like other variables, arrays must be declared before you use them. Declaration can be separate from the actual creation of the array. Here are some examples of declaring variables that are arrays of primitives (lines 1 through 3) and objects (lines 4 and 5):
1. int counts[] ; 2. int[] counts ; // 1 and 2 are equivalent 3. boolean flags [ ] ; // extra spaces are not significant 4. String names[] ; 5. MyClass[][] things ; // a two-dimensional array of objects
If the following lines were in a method and the method was executed, line 2 would print "counts = null" because the array object has not yet been constructed.
1. int counts[] ;
2. System.out.println("counts = " + counts );
Construction
You cannot do anything with an array variable until the array has been constructed with the new operator. The statement that constructs an array must give the size, as shown in the following code fragment, assumed to follow lines 1 through 6 in the previous code (the code in line 9 assumes that an integer primitive nStrings has been initialized):
7. counts = new int[20] ; 8. flags = new boolean[ 5 ] ; 9. names = new String[ nStrings ] ;
After this code executes, memory for the arrays will be reserved and initialized. The array reference variables will have references to array objects of known types. In other words, the type of an array object controls what can be stored in the indexed locations. You can test the type of an array variable with the instanceof operator, using a name for the reference type that looks like an array declaration. For example, using the flags variable initialized in line 8, the following test would result in true:
10. if( flags instanceof boolean[] )
Exactly what is in the array locations after construction depends on the type. Integer and floating-point primitive arrays have elements initialized to zero values. Arrays of boolean types have elements of false values. Arrays of object types have null references.
You can combine declaration of an array variable with construction, as shown in the following code examples:
1. float rates[] = new float[33] ; 2. String files[] = new String[ 1000 ] ;
CAUTION
You must remember the distinction between the status of arrays of primitives and the status of arrays of object references after the array is constructed. Arrays of primitives have elements that are initialized to default values. Arrays of objects have the value null in each element. You are practically guaranteed to have a related question on the exam.
Combined Declaration, Construction, and Initialization
Java allows a statement format for combined declaration, construction, and initialization of arrays with literal values, as shown in the following code examples (note that the String array defined in lines 2, 3, and 4 is two dimensional):
1. int[] fontSize = { 9, 11, 13, 15, 17 } ;
2. String[][] fontDesc = {
3. {"TimesRoman", "bold"}, {"Courier","italic"},
4. {"ZapfDingBats", "normal"} } ;
Initialization
To provide initial object references or primitive values other than the default, you have to address each element in the array. In the following code, we declare and create an array of Rectangle objects, and then create the Rectangle objects for each element:
1. Rectangle hotSpots[] = new Rectangle[10];
2. for( int i = 0 ; i < hotSpots.length ; i++ ){
3. hotSpots[i] = new Rectangle(10 * i, 0, 10, 10);
4. }
The Java compiler checks the assignment of values to array positions just like it checks assignment to single variables. For example, the following code would not compile because the compiler knows that 1024 is outside the range of byte variables.
byte[] x = new byte[ 200 ]; x[0] = 1024 ;
At runtime, Java checks every array index against the known size of the array so that it is impossible to place data outside the reserved memory space. An attempt to use a bad index in an array operation results in an ArrayIndexOutOfBoundsException being thrown. We talk more about exceptions in Chapter 8, "Exceptions and Assertions."
Object Array Sample Question
The following sample question is related to object arrays. This example caused many errors in mock exam tests. We feel this difficulty illustrates two important points about taking the exam:
-
Read the question carefully.
-
Remember that the wrapper class names, although spelled like the primitives, always start with a capital letter.
-
What will happen when you try to compile and run the following application?
-
The text "Flag 1 is true" will be written to standard output.
-
The text "Flag 1 is false" will be written to standard output.
-
The text "Flag 1 is null" will be written to standard output.
-
The compiler will object to line 2.
1. public class Example {
2. public Boolean flags[] = new Boolean[4] ;
3. public static void main(String[] args){
4. Example E = new Example();
5. System.out.println( "Flag 1 is " + E.flags[1] );
6. }
7. }
Answer C is correct. Most people forget that Boolean is a wrapper class for boolean values and thus the array creation statement in line 2 merely created the array. All of the references in that array are initialized to null.