OCA Java SE 7 Programmer I Certification Guide By Mela Gupta. Arrays

Transcription

1 1 OCA Java SE 7 Programmer I Certification Guide By Mela Gupta In the OCA Java SE 7 programmer exam, you ll be asked many questions on how to create, modify, and delete String, StringBuilder, arrays, and ArrayList objects. In this article, based on chapter 4 of OCA Java SE 7 Programmer I Certification Guide, author Mala Gupta gives an in-depth account of accessing elements in asymmetric multi-dimensional arrays. You may also be interested in Arrays In this article, we ll cover declaration, allocation, and initialization of one dimensional and multi-dimensional array. We ll cover the differences between arrays of primitive data types and arrays of objects. What is an array? An array is an object that stores a collection of values. The fact that an array itself is an object is overlooked by many. I ll reiterate: an array is an object itself, which implies that it stores references to the data in stores. It can store two types of data: A collection of primitive data types A collection of objects An array of primitives stores a collection of values that constitute the primitive values themselves. (With primitives there are no objects to reference.) An array of objects stores a collection of values, which are in fact heap-memory addresses or pointers. The addresses point to (reference) the object instances that your array is said to store, which means object arrays store references (to objects) and primitive arrays store primitive values. The members of an array are defined in contiguous (continuous) memory locations; hence, they offer improved access speed. (You should be able to quickly access all the students of a class, if they all can be found next to each other.) Figure 1 shows the array intarray of the primitive int data type and an array objarray of String objects. Unlike intarray, objarray stores references to String objects. Figure 1 An array of int primitive data type and String objects NOTE Arrays are objects and refer to a collection of other primitive data types or objects.

2 2 In Java, you can define one-dimensional and multi-dimensional arrays. A one-dimensional array is an object that refers to a collection of scalar values repeated one or more times. A two-dimensional (or more) array is referred to as a multi-dimensional array. A two-dimensional array refers to a collection of objects, where each of the objects is a one dimensional array. Similarly, a three-dimensional array refers to a collection of two-dimension arrays, and so on. Figure 2 depicts a one-dimensional and multi-dimensional arrays (two-dimensional and threedimensional). Figure 2 One-dimensional and multi-dimensional (two- and three-dimensional) arrays Note that multi-dimensional arrays may or may contain the same number of elements in each row or columns. Creation of an array involves three steps, as follows: Declaration of an array Allocation of array Initialization of array elements You can create an array by executing the previous steps using separate lines or code or you can combine these steps on the same line of code. Let s start with the first approach, by completing each step on a separate line of code. Array declaration Array declaration is composed of array type and array variable, as shown in figure 3. Figure 3 Array declaration is composed of array type and variable The type of objects that an array can store depends on its type. An array type is followed by empty pairs of square brackets []. To declare an array, specify its type and the name of the array variable. The following is an example of declaration of array of int and String values: int intarray[]; #A String[] strarray; #A int[] multiarray[]; #B #A One-dimensional array #B Multi-dimensional array The number of bracket pairs indicates the depth of array nesting. Java doesn t impose any theoretical limit on the level or array nesting. The square brackets can follow the array type of its name, as shown in figure 4.

3 3 Figure 4 Square brackets can follow either the variable name or its type. In the case of multi-dimensional arrays, it can follow both of them. Array declaration only creates a variable that refers to null, as shown in figure 5. Figure 5 Array declaration creates a variable that refers to null Because no elements of an array are created when it s declared, it s invalid to define the size of an array with its declaration. The following code won t compile: int intarray[2]; #A String[5] strarray; #A int[2] multiarray[3]; #A #A Array size can t be defined with the array declaration. This code won t compile. An array type can be any of the following: Primitive data type Interface Abstract class Concrete class We declared an array of an int primitive type and a concrete class String previously. We ll discuss some complex examples on abstract classes and interfaces further in this article. Array allocation As the name suggests, array allocation will allocate memory for the elements of an array. When you allocate memory for an array, you should specify its dimensions, such as the number of elements the array should store. To follow are a few examples: int intarray[]; #A String[] strarray; #A int[] multiarr[]; #A intarray = new int[2]; #B strarray = new String[4]; #B multiarr = new int[2][3]; #B #A Array declaration #B Note usage of keyword new to allocate an array Because an array is an object, it s allocated using the keyword new, followed by the type of value that it stores and then its size. The code won t compile if you don t specify the size of the array or place the array size on the left of the = sign, as follows:

4 4 intarray = new int[]; #A intarray[2] = new int; #B #A Won t compile. Array size missing. #B Won t compile. Array size placed incorrectly. The size of the array should evaluate to a numeric value. Java accepts an expression to specify as the size of an array. The following are valid array allocations: strarray = new String[2*5]; #A int x = 10, y = 4; strarray = new String[x*y]; #B strarray = new String[Math.max(2, 3)]; #C #A 2*5 evaluates to a numeric value #B This is acceptable. Expression x*y evaluates to a numeric value #C This is acceptable. Math.max(2,3) return an int value Let s allocate the multi-dimensional array multiarr, as follows: int[] multiarr[]; #A multiarr = new int[2][3]; #B intarray = new int[2][]; #C #A Array declaration #B OK #C OK to define the size in only the first square bracket It s interesting to note what happens when multi-dimensional array multiarr is allocated by defining size for a single and both its dimensions. This difference is shown in figure 6. Figure 6 Difference in array allocation of a two-dimensional array when it s allocated using values for only one of its dimensions, and for both its dimensions. You can t allocate a multi-dimensional array as follows: int[] multiarr[]; #A multiarr = new int[]; #1 intarray = new int[][3]; #2 #A Multi-dimensional array declaration #1 Non-matching square brackets #2 Size in first square bracket missing #1 won t compile because there is a mismatch in the number of square brackets on both sides of the assignment operator (=) sign. The compiler required [][] in the right-hand side of the assignment operator, but it finds only []. Once allocated, the array elements store their default values. For arrays that store objects, all of the allocated arrays elements store null. For arrays that store primitive values, the default values depend on the exact data types stored by them. EXAM TIP Once allocated, all the array elements store their default values. Elements of array that store object refer to null. Elements of array that store primitive data types, store 0, 0.0, false or /u0000 for integer (byte, short, int, long), decimal (float and double), boolean, and char data respectively. Array initialization You can initialize the previously defined arrays as follows:

5 5 int intarray[]; #A intarray = new int[2]; #B for (int i=0; i<intarray.length; i++) { #1 intarray[i] = i + 5; #1 } #1 intarray[0] = 10; #2 intarray[1] = 1870; #2 #A Array declaration #B Array allocation #1 Initialize array using a for loop #2 Initialize individual array elements #1 Uses a for loop to initialize array intarray with the required values. #2 Initializes the individual array elements without using a for loop. Note that all array objects can access the instance variable length, which stores the array size. Similarly, a String array can be declared, allocated, and initialized as follows: String[] strarray; #A strarray = new String[4]; #B for (int i=0; i<strarray.length; i++) { #C strarray[i] = new String ("Hello" + i); #C System.out.println (strarray[i]); #C } strarray[1] = "Summer"; #D strarray[3] = "Winter"; #D strarray[0] = "Autumn"; #D strarray[2] = "Spring"; #D #A Array declaration #B Array allocation #C Array initialization using a for loop #B Array initialization without using a for loop When you initialize a two-dimensional array, you can use nested for loops to initialize its array elements. Also notice that, to access an element in a two-dimensional array, you should use two array position values, as follows: int[] multiarr[]; #A multiarr = new int[2][3]; #B for (int i=0; i<multiarr.length; i++) { #C for (int j=0; j<multiarr[i].length; j++) { #C multiarr[i][j] = i + j; #C System.out.println (multiarr[i][j]); #C } #C } #C multiarr[0][0] = 10; #D multiarr[1][2] = 1210; #D multiarr[0][1] = 110; #D multiarr[0][2] = 1087; #D #A Array declaration #B Array allocation #C Array initialization using a for loop #B Array initialization without using a for loop Combining array declaration, allocation, and initialization You can combine all the previously mentioned steps of array declaration, allocation, and initialization in one single step, as follows: int intarray[] = {0, 1}; String[] strarray = {"Summer", "Winter"}; int multiarray[][] = { {0, 1}, {3, 4, 5}};

6 6 Notice the following in the previous code: It doesn t use the keyword new to initialize an array. It doesn t specify size of array. It uses a single pair of curly brackets to define values for one-dimensional array and multiple pair of curly brackets to define a multi-dimensional array. All of the previous steps of array declaration, allocation, and initialization can be combined in one step, in another way, as follows: int intarray2[] = new int[]{0, 1}; String[] strarray2 = new String[]{"Summer", "Winter"}; int multiarray2[][] = new int[][]{ {0, 1}, {3, 4, 5}}; Unlike the first approach, the previous code uses the keyword new to initialize an array. If you try to specify the size of an array with the previous approach, the code won t compile. Here are a few examples: int intarray2[] = new int[2]{0, 1}; String[] strarray2 = new String[2]{"Summer", "Winter"}; int multiarray2[][] = new int[2][]{ {0, 1}, {3, 4, 5}}; EXAM TIP When you combine an array declaration, allocation, and initialization in a single step, you can t specify the size of the array. The size of the array is calculated by the number of values that are assigned to array. Another important point to note is that, if you declare and initialize an array using two separate lines of code, you ll use the keyword new to initialize the values. The following lines of code are correct: int intarray[]; intarray = new int[]{0, 1}; But you can t miss the keyword new and initialize your array, as follows: int intarray[]; intarray = {0, 1}; Asymmetrical multidimensional arrays At the beginning of this section, we mentioned that a multi-dimensional array can be asymmetrical; it may not define the same number of columns for each of its rows. The following example is of an asymmetrical twodimensional array: String multistrarr[][] = new String[][]{ {"A", "B"}, null, {"Jan", "Feb", "Mar"}, }; Figure 7 shows the pictorial representation of this asymmetrical array:

7 7 Figure 7 An asymmetrical array As you ve noticed, multistrarr[1] refers to a null value an attempt to access any element of this array, like multistrarr[1][0], will throw an exception. Array of interfaces, abstract classes, and class Object In the part about array declaration, I mentioned that the type of an array can also be an interface and an abstract class. What values do elements of these arrays store? Let s take a look at some of the examples. Interface type Elements of this array are either null or objects that implement this interface type. For example, for the interface MyInterface, the array interfacearray can store references to objects of either the class MyClass1 or MyClass2: interface MyInterface {} class MyClass1 implements MyInterface {} class MyClass2 implements MyInterface {} class Test { MyInterface[] interfacearray = new MyInterface[] { new MyClass1(), null, new MyClass2() }; } Abstract class type Elements of this array are either null or objects of concrete classes that extend this abstract class. abstract class Vehicle{} class Car extends Vehicle {} class Bus extends Vehicle {} class Test { Vehicle[] vehiclearray = { new Car(), new Bus(), null}; #A } #A null is valid element Let s discuss a special case where the type of an array is Object. Object Because all classes extend the class java.lang.object, elements of this array can refer to any object. Here is an example: interface MyInterface {} class MyClass1 implements MyInterface {} abstract class Vehicle{}

8 8 class Car extends Vehicle {} class Test { Object[] objarray = new Object[] { new MyClass1(), null, #A new Car(), new java.util.date(), new String("name"), new Integer [7] #1 }; } #A null is a valid element #1 Array element of type Object can refer to another array #1 is valid code. Because an array is an object, the element of the array of java.lang.object can refer to another array. Figure 7 shows a pictorial representation of the previously created array, objarray: Figure 7 An array of class Object Members of an array All of the arrays are objects and can access the following members: public final field length The variable length contains the number of components of the array. public method clone This method overrides the method clone defined in class Object, but doesn t throw checked exceptions. The return type of this method is same as array s type. For example, for an array type Type[], this method returns Type[]. Methods inherited from the class Object, except the method clone. Recall that a String uses method length() to retrieve its length. With arrays, you can use its variable length to determine the number of its elements. In the exam, you may be tricked by code that tries to access the length of a String using variable length. Note the correct combination of class and member used to access its length: String Retrieve length using the method length() Array Determine element count using the variable length I have an interesting way to remember this rule: As opposed to an array, you ll invoke a lot of methods on String objects. So you use method length() to retrieve length of String and variable length to retrieve length of an array. Summary An array is an object that stores a collection of values. An array can store a collection of primitive data types or a collection of objects. You can define one-dimensional and multi-dimensional arrays. A one-dimensional array is an object that refers to a collection of scalar values repeated one or more times. A two-dimensional (or more) array is

9 9 referred to as a multi-dimensional array. A two-dimensional array refers to a collection of objects, where each of the objects is a one dimensional array. Similarly, a three-dimensional array refers to a collection of two-dimension arrays, and so on. Arrays can be declared, allocated and initialized in a single or multiple steps. A two-dimensional array may not be symmetrical and each of its rows can define different numbers of members. You can define arrays of interfaces, abstract classes and the class java.lang.object. All the arrays are objects and can access variable length, and methods inherited class java.lang.object.

10 10 Here are some other Manning titles you might be interested in: Unit Testing in Java Lasse Koskela Making Java Groovy Kenneth Kousen Play for Java Nicolas Leroux and Sietse de Kaper Last updated: August 6, 2012