http://www.developer.com/

Back to article

The Essence of OOP using Java, Array Objects, Part 2


June 5, 2002

Preface

This series of lessons is designed to teach you about the essence of Object-Oriented Programming (OOP) using Java.

The first lesson in the series was entitled The Essence of OOP Using Java, Objects, and Encapsulation.  The previous lesson was entitled The Essence of OOP using Java, Array Objects, Part 1.

You may find it useful to open another copy of this lesson in a separate browser window.  That will make it easier for you to scroll back and forth among the different listings while you are reading about them.

For further reading, see my extensive collection of online Java tutorials at Gamelan.com. A consolidated index is available at Baldwin's Java Programming Tutorials.

Preview

This lesson explains various details regarding the use of array objects in Java, and illustrates many of those details through the use of sample code.

A sample program shows you three ways to emulate traditional two-dimensional rectangular arrays, and also shows you how to create and use ragged arrays.

Discussion and Sample Code

Array objects

A different syntax is required to create array objects than the syntax normally used to create ordinary objects.  Array objects are accessed via references.  Any of the methods of the Object class can be invoked on a reference to an array object.

The indices of a Java array object

Array objects encapsulate a group of variables, which don't have individual names. They are accessed using positive integer index values.  The integer indices of a Java array object always extend from 0 to (n-1) where n is the length of the array encapsulated in the object.

Multidimensional arrays

All array objects in Java encapsulate one-dimensional arrays.  However, the component type of an array may itself be an array type.  This makes it possible to create array objects whose individual components refer to other array objects. This is the mechanism for creating multi-dimensional or ragged arrays in Java.

Such a structure of array objects can be thought of as a tree of array objects, with the data being stored in the array objects that make up the leaves of the tree.

Array types

When declaring a reference variable capable of referring to an array object, the array type is declared by writing the name of an element type followed by some number of empty pairs of square brackets [].  This is illustrated in Listing 1, which declares a reference variable named v1, capable of storing a reference to a two-dimensional array of type int.
 

  int[][] v1;

Listing 1
(Note that Listing 1 doesn't really declare a two-dimensional array in the traditional sense of other programming languages.  Rather, it declares a reference variable capable of storing a reference to a one-dimensional array object, which in turn is capable of storing references to one-dimensional array objects of type int.)
Multiple pairs of square brackets are allowed

The components in an array object may refer to other array objects.  The number of bracket pairs used in the declaration of the reference variable indicates the depth of array nesting (in the sense that array elements can refer to other array objects).  This is one of the ways that Java implements the concept of traditional multi-dimensional arrays (I will show you some other ways later in this lesson).

The code in Listing 1 shows two levels of nesting for the reference variable of type int[][].

Length not part of variable declaration
(Note that an array's length is not part of its type or reference variable declaration.)

Ragged arrays
(Note also that multi-dimensional arrays, when implemented in this fashion, are not required to represent rectangles, cubes, etc.  For example, the number of elements in each row of a Java two-dimensional array can be different.  Some authors refer to this as a ragged array.)

Allowable types

The specified element type of an array may be any primitive or reference type. Note, however, that all elements of the array must be of the same type (consistent with the type-conversion rules discussed below).

Listing 2 shows the declaration of a reference variable capable of referring to a three-dimensional array object of element type Button (Button is one of the classes in the standard class library).
 

  Button[][][] v2;

Listing 2

Rules of type conversion and assignment compatibility apply

The normal rules of type conversion and assignment compatibility apply when creating and populating array objects.  For example, if the specified type is the name of a non-abstract class, a null reference or a reference to any object instantiated from that class or any subclass of that class may be stored in the array element.

The generic class Object

For example, Listing 3 shows the declaration of a reference variable capable of referring to a one-dimensional array object of element type Object.

Since Object is the superclass of all other classes, this array object is capable of storing references to objects instantiated from any other class.  (As we saw in the previous lesson, it is also capable of storing a reference to any other array object as well.)
 

  Object[] v3;

Listing 3

Primitive type conversions

Similarly, if the declared element type for the array object is one of the primitive types, the elements of the array can be used to store values of any primitive type that is assignment compatible with the declared type (without the requirement for a cast).

For example, the code in Listing 4 shows the creation of a one-dimensional array object capable of storing values of type int.  The array object has a length of 3 elements, and the object's reference is stored in a reference variable named v1.
 

    int[] v1;
    v1 = new int[3];
    byte x1 = 127;
    short x2 = 16384;
    int x3 = 32000;
    v1[0] = x1;
    v1[1] = x2;
    v1[2] = x3;

Listing 4

Assignment-compatible assignments

Values of the types byte, short, and int, are stored in the elements of the array object.

Actual type is lost in the process
(It should be noted that the byte and short values are converted to type int as they are stored.  When retrieved later, they will be retrieved as type int.  Any indication that these values were ever of any type other than int is lost in the process of storing and retrieving the values.)
What about class types?

If the declared element type is the name of a class, (which may or may not be abstract), a null reference or a reference to any object instantiated from the class or any subclass of the class may be stored in the array element.

(Obviously you can't store a reference to an object instantiated from an abstract class, because you can't instantiate an abstract class.)
What about an interface type?

If the declared element type is an interface type, a null reference or a reference to any object instantiated from any class that implements the interface can be stored in the array element.

(This is an extremely powerful concept, allowing references to objects instantiated from many different classes to be collected into an array as the interface type.)
Array reference variables

All array objects are accessed via references.  A reference variable whose declared type is an array type does not contain an array.  Rather, it contains either null, or a reference to an array object.

Allocation of memory

Declaring the reference variable does not create an array, nor does it allocate any space for the array components.  It simply causes memory to be allocated for the reference variable itself, which may later contain a reference to an array object.

Initialization

In the same sense that it is possible to declare a reference variable for an ordinary object, and initialize it with a reference to an object when it is declared, it is also possible to declare a reference to an array object and initialize it with a reference to an array object when it is declared.  This is illustrated in Listing 5, which shows the following operations combined into a single statement:

  • Declaration of a variable to contain a reference to an array object
  • Creation of the array object
  • Storage of the array object's reference in the reference variable
    int[] v1 = new int[3];

Listing 5

Can refer to different array objects

The length of an array is not established when the reference variable is declared.  As with references to ordinary objects, a reference to an array object can refer to different array objects at different points in the execution of a program.

For example, a reference variable that is capable of referring to an array of type int[] can refer to an array object of a given size at one point in the program and can refer to a different array object of the same type but a different size later in the program.

Placement of square brackets

When declaring an array reference variable, the square brackets [] may appear as part of the type, or following the variable name, or both.  This is illustrated in Listing 6.
 

    int[][] v1;
    int[] v2[];
    int v3[][];


Listing 6

Type and length

Once an array object is created, its type and length never changes.  A reference to a different array object must be assigned to the reference variable to cause the reference variable to refer to an array of different length.

Creating the actual array object

An array object is created by an array creation expression or an array initializer.

An array creation expression (or an array initializer) specifies:

  • The element type
  • The number of levels of nested arrays
  • The length of the array for at least one of the levels of nesting
Two valid array creation expressions are illustrated by the boldface statements in Listing 7.
 
    int[][] v1;
    int[] v2[];

    v1 = new int[2][3];
    v2 = new int[10][];

Listing 7

A two-dimensional rectangular array

The first boldface statement creates an array object of element type int with two levels of nesting.  This array object can be thought of as a traditional two-dimensional rectangular array having two rows and three columns.

A ragged array

The second boldface statement also creates an array object of element type int with two levels of nesting.  However, the number of elements in each row is not specified at this point, and it is not appropriate to think of this as a two-dimensional rectangular array.  In fact, once the number of elements in each row has been specified, it may not describe a rectangle at all.  Some authors refer to an array of this type as a ragged array.

The length of the array

The length of the array is always available as a final instance variable named length.  I will show you how to use the value of length in a sample program later in this lesson.

Accessing array elements

An array element is accessed by an array access expression.  The access expression consists of an expression whose value is an array reference followed by an indexing expression enclosed by matching square brackets.

The boldface expression in Listing 8 illustrates an array access expression (or perhaps two concatenated array access expressions).
 

    int[][] v1 = new int[2][3];
    System.out.println(v1[0][1]);

Listing 8

First-level access

This array access expression first accesses the contents of the element at index 0 in the array object referred to by the reference variable named v1.  This is a reference to a second array object (note the double matching square brackets, [][]).

Second-level access

The array access expression in Listing 8 uses that reference to access the value stored in the element at index value 1 in the second array object.  That value is then passed to the println method for display on the standard output device.

(In this case, the value 0 is displayed, because array elements are automatically initialized to default values when the array object is created.  The default value for all primitive numeric values is zero.)
Zero-based indexing

All array indexes in Java begin with 0. An array with length n can be indexed by the integers 0 to (n-1).  Array accesses are checked at runtime.  If an attempt is made to access the array with any other index value, an ArrayIndexOutOfBoundsException will be thrown.

Index value types

Arrays must be indexed by integer values of the following types: int, short, byte, or char.  For any of these types other than int, the value will be promoted to an int and used as the index.

An array cannot be accessed using an index of type long.  Attempting to do so results in a compiler error.

Default initialization

If the elements in an array are not purposely initialized when the array is created, the array elements will be automatically initialized with default values.  The default values are:

  • All reference types:  null
  • Primitive numeric types:  0
  • Primitive boolean type:  false
  • Primitive char type:  the Unicode character with 16 zero-valued bits ('\u0000' (the NUL character)
Explicit initialization of array elements

The values in the array elements may be purposely initialized when the array object is created using a comma-separated list of expressions enclosed by matching curly braces.  This is illustrated in Listing 9.
 

    int[] v1 = {1,2,3,4,5};

Listing 9
No new operator
(Note that this format does not make use of the new operator.  Also note that the expressions in the list may be much more complex than the simple literal values shown in Listing 9.)
Length and order

The length of the constructed array will equal the number of expressions in the list.

The expressions in an array initializer are executed from left to right in the order that they occur in the source code.  The first expression specifies the value at index value zero, and the last expression specifies the value at index value n-1 (where n is the length of the array).

Each expression must be assignment-compatible with the array's component type, or a compiler error will occur.

A sample program

The previous paragraphs in this lesson have explained some of the rules and characteristics regarding array objects.  They have also illustrated some of the syntax involved in the use of array objects in Java.

More powerful and complex

Many aspiring Java programmers find the use of array objects to be something less than straightforward, and that is understandable.  In fact, Java array objects are somewhat more powerful than array structures in many other programming languages, and this power often manifests itself in additional complexity.

A traditional two-dimensional rectangular array

Some of that complexity is illustrated by the program named Array07, shown in Listing 26 near the end of this lesson.  This program illustrates three different ways to accomplish essentially the same task using array objects in Java.  That task is to emulate a traditional two-dimensional rectangular array as found in other programming languages.  Two of the ways that are illustrated are essentially ragged arrays with subarrays having equal length.

Ragged arrays

The program also illustrates two different ways to work with array objects and ragged arrays.

Will discuss in fragments

As is my practice, I will discuss and explain the program in fragments.

All of the interesting code in this program is contained in the main method, so I will begin my discussion with the first statement in the main method.

Create a two-dimensional rectangular array structure

Listing 10 creates an array structure that emulates a traditional rectangular array with two rows and three columns.
 

    Object[][] v1 = new Object[2][3];

Listing 10
Requires all rows to be same length
(Note that unlike the ragged array structures to be discussed later, this approach requires all rows to be the same length.)
Reference variable declaration

The code in Italics (to the left of the equal sign, =) in Listing 10 declares a reference variable named v1.  This reference variable is capable of holding a reference to an array object whose elements are of the type Object[].

In other words, this reference variable is capable of holding a reference to an array object, whose elements are capable of holding references to other array objects, whose elements are of type Object.

Two levels of nesting
(The existence of double matching square brackets in the variable declaration in Listing 10 indicates two levels of nesting.)
Not very general

This is not a very general approach.  In particular, the elements in the array object referred to by v1 can only hold references to other array objects whose element type is Object (or references to array objects whose element type is a subclass of Object).

The elements in the array object referred to by v1 cannot hold references to ordinary objects instantiated from classes, or array objects whose element type is a primitive type.

In other words, the elements in the array object referred to by v1 can only hold references to other array objects.  The element types of those array objects must be assignment compatible with the type Object (this includes interface types and class types but not primitive types).

A tree of empty array objects

The boldface code in Listing 10 (to the right of the equal sign, =) creates a tree structure of array objects.  The object at the root of the tree is an array object of type Object[], having two elements (a length of two).

The reference variable named v1 refers to the array object that forms the root of the tree.

Each of the two elements in the root array object is initialized with a reference to another array object.

(These two objects might be viewed as subarrays, or as child nodes in the tree structure).
Each of the child nodes is an array object of type Object, and has a length of three.

Each element in each of the two child node array objects is initialized to the value null (this is the default initialization for array elements of reference types that don't yet refer to an object).

Recap

To recap, the reference variable named v1 contains a reference to a two-element, one-dimensional array object.  Each element in that array object is capable of storing a reference of type Object[] (a reference to another one-dimensional array object of type Object).

Two subarray objects

Two such one-dimensional subarray (or child node) objects, of element type Object, are created.  References to the two subarray objects are stored in the elements of the two-element array object at the root of the tree.

Each of the subarray objects has three elements.  Each element is capable of storing a reference to an object as type Object.

The leaves of the tree
(These two subarray objects might be viewed as the leaves of the tree structure.)
Initialize elements to null

However, the objects of type Object don't exist yet.  Therefore, each element in each of the subarray objects is automatically initialized to null.

Arrays versus subarrays
(Note that there is no essential difference between an array object and a subarray object in the above discussion.  The use of the sub prefix is used to indicate that an ordinary array object belongs to another array object, because the reference to the subarray object is stored in an element of the owner object.)
Many dimensions are possible

Multi-dimensional arrays of any (reasonable) depth can be emulated in this manner.  An array object may contain references to other array objects, which may contain references to other array objects, and so on.

The leaves of the tree structure

Eventually, however, the elements of the leaves in the tree structure must be specified to contain either primitive values or references.  This is where the data is actually stored.

(Note however, that if the leaves are specified to contain references of type Object, they may contain references to other array objects of any type, and the actual data could be stored in those array objects.)
The length of an array

Every array object contains a public final instance variable named length, which contains an integer value specifying the number of elements in the array.

Once created, the length of the array encapsulated in an array object cannot change.  Therefore, the value of length specifies the length of the array throughout the lifetime of the array object.

Using length to populate the leaves of the tree structure

The value of length is very handy when processing array objects.  This is illustrated in Listing 11, which uses a nested for loop to populate the elements in the leaves of the tree structure referred to by v1(The elements in the leaf objects are populated with references to objects of type Integer.)
 

    for(int i=0;i<v1.length;i++){
      for(int j=0;j<v1[i].length;j++){
        v1[i][j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop

Listing 11

Using length in loop's conditional expressions

Hopefully by now you can read and understand this code without a lot of help from me.  I will point out, however, that the value returned by v1.length (in the conditional expression for the outer loop) is the number of leaves in the tree structure (this tree structure has two leaves).

I will also point out that the value returned by v1[i].length (in the conditional expression for the inner loop) is the number of elements in each leaf array object (each leaf object in this tree structure has three elements).

Finally, I will point out that the expression v1[i][j] accesses the jth element in the ith leaf, or subarray.  In the traditional sense of a rectangular array, this could be thought of as the jth column of the ith row.  This mechanism is used to store object references in each element of each of the leaf array objects.

Populate with references to Integer objects

Thus, each element in each leaf array object is populated with a reference to an object of the type Integer.  Each object of the type integer encapsulates an int value calculated from the current values of the two loop counters.

Display leaf object contents

In a similar manner, the code in Listing 12 uses the length values in the conditional expressions of nested for loops to access the references stored in the elements of the leaf array objects, and to use those references to access and display the values encapsulated in the Integer objects whose references are stored in those elements.
 

    for(int i=0;i<v1.length;i++){
      for(int j=0;j<v1[i].length;j++){
        System.out.print(
                       v1[i][j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop

Listing 12

The rectangular output

The code in Listing 12 produces the following output on the screen.

1 2 3
2 4 6

As you can see, this emulates a traditional two-dimensional array having two rows and three columns.

A ragged array with two rows and three columns

The second approach to emulating a traditional two-dimensional rectangular array will create a ragged array where each row is the same length.

(With a ragged array, the number of elements in each row can be different.)
The most significant thing about this approach is the manner in which the tree of array objects is created (see Listing 13).
 
    Object[][] v2 = new Object[2][];

Listing 13

Three statements required

With this approach, three statements are required to replace one statement from the previous approach.  (Two additional statements are shown in Listing 14.)

A single statement in the previous approach (Listing 10) created all three array objects required to construct the tree of array objects, and initialized the elements in the leaf array objects with null values.

Create only the root array object

However, the boldface code in Listing 13 creates only the array object at the root of the tree.  That array object is an array object having two elements capable of storing references of type Object[].

Empty square brackets

If you compare this statement with the statement in Listing 10, you will notice that the right-most pair of square brackets in Listing 13 is empty.  Thus, Listing 13 creates only the array object at the root of the tree, and initializes the elements in that array object with null values.

Leaf array objects don't exist yet

The leaf array objects don't exist at the completion of execution of the statement in Listing 13.

Create the leaf array objects

The boldface portions of the statements in Listing 14 create two array objects of element type Object.
 

    v2[0] = new Object[3];
    v2[1] = new Object[3];

Listing 14

Save the references to the leaves

References to these two leaf objects are stored in the elements of the array object at the root of the tree, (which was created in Listing 13).  Thus, these two array objects become the leaves of the tree structure of array objects.

This completes the construction of the tree structure.  Each element in each leaf object is initialized with null.

Why bother?

You might ask why I would bother to use this approach, which requires three statements in place of only one statement in the previous approach.

The answer is that I wouldn't normally use this approach if my objective were to emulate a traditional rectangular array.  However, this approach is somewhat more powerful than the previous approach.

The lengths of the leaf objects can differ

With this approach, the length of the two leaf array objects need not be the same.  Although I caused the length of the leaf objects to be the same in this case, I could just as easily have caused them to be different lengths (I will illustrate this capability later in the program).

Populate and display the data

If you examine the complete program in Listing 26 near the end of the lesson, you will see that nested for loops, along with the value of length was used to populate and display the contents of the leaf array objects.  Since that portion of the code is the same as with the previous approach, I won't show and discuss it here.

The rectangular output

This approach produced the following output on the screen, (which is the same as before):

1 2 3
2 4 6

Now for something really different

The next approach that I am going to show you for emulating a two-dimensional rectangular array is significantly different from either of the previous two approaches.

Not element type Object[]

In this approach, I will create a one-dimensional array object of element type Object (not element type Object[]).  I will populate the elements of that array object with references to other array objects of element type Object.  In doing so, I will create a tree structure similar to those discussed above.

The length of the leaf objects

As with the second approach above, the array objects that make up the leaves of the tree can be any length, but I will make them the same length in order to emulate a traditional rectangular two-dimensional array.

Create the array object

First consider the statement shown in Listing 15.  Compare this statement with the statements shown earlier in Listing 10 and Listing 13.
 

    Object[] v3 = new Object[2];
Listing 15

No double square brackets

Note in particular that the statement in Listing 15 does not make use of double square brackets, as was the case in Listing 10 and Listing 13.  Thus, the statement show in Listing 15 is entirely different from the statements shown in Listing 10 and Listing 13.

Declare a reference variable

That portion of the statement shown in Italics (to the left of the equal sign, =) declares a reference variable capable of storing a reference to an array object whose elements are capable of storing references of the type Object (not type Object[] as in the previous examples).

Refer to the root object

This reference variable will refer to an array object that forms the root of the tree structure.  However, the root object in this case will be considerably different from the root objects in the previous two cases.

In the previous two cases, the elements of the root object were required to store references of type Object[] (note the square brackets). In other words, an array object whose elements are of type Object[] can only store references to other array objects whose elements are of type Object.

A more general approach

However, an array object whose elements are of type Object (as is the case here), can store:

  • References to any object instantiated from any class
  • References to array objects whose elements are of any type (primitive or reference)
  • A mixture of the two kinds of references.
Therefore, this is a much more general, and much more powerful approach.

A price to pay

However, there is a price to pay for the increased generality and power.  In particular, the programmer who uses this approach must have a much better understanding of Java object-oriented programming concepts than the programmer who uses the two approaches discussed earlier in this lesson.

Particularly true relative to first approach

This is particularly true relative to the first approach discussed earlier.  That approach is sufficiently similar to the use of multi-dimensional arrays in other languages that a programmer with little understanding of Java object-oriented programming concepts can probably muddle through the syntax based on prior knowledge.  However, it is unlikely that a programmer could muddle through this approach without really understanding what he is doing.

Won't illustrate true power

Although this approach is very general and very powerful, this sample program won't attempt to illustrate that power and generality.  Rather, this sample program will use this approach to emulate a traditional two-dimensional rectangular array just like the first two approaches discussed earlier. (Later, I will also use this approach for a couple of ragged arrays.)

Populate the root object

The two statements in Listing 16 create two array objects, each having three elements.  Each element is capable of storing a reference to any object that is assignment compatible with the Object type.

(Assignment compatibility includes a reference to any object instantiated from any class, or a reference to any array object of any type (including primitive types), or a mixture of the two.)
    v3[0] = new Object[3];
    v3[1] = new Object[3];

Listing 16

References to the two new array objects are stored in the elements of the array object that forms the root of the tree structure.  The two new array objects form the leaves of the tree structure.

Populate the leaf array objects

As in the previous two cases, the code in Listing 17 uses nested for loops to populate the array elements in the leaf objects with references to new Integer objects.  (The Integer objects encapsulate int values based on the loop counter values for the outer and inner loops.)
 

    for(int i=0;i<v3.length;i++){
      for(int j=0;
            j<((Object[])v3[i]).length;
                                  j++){
        ((Object[])v3[i])[j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop

Listing 17

Added complexity

The added complexity of this approach manifests itself in

  • The cast operators shown in boldface Italics in Listing 17
  • The attendant required grouping of terms within parentheses
Inside and outside the parentheses

Note that within the inner loop, one of the square-bracket accessor expressions is inside the parentheses and the other is outside the parentheses.

Why are the casts necessary?

The casts are necessary to convert the references retrieved from the array elements from type Object to type Object[].  For example, the reference stored in v3[i] is stored as type Object.

Get length of leaf array object

The cast in the following expression converts that reference to type Object[] before attempting to get the value of length belonging to the array object whose reference is stored there.

((Object[])v3[i]).length

Assign a value to an element in the leaf array object

Similarly, the following expression converts the reference stored in v3[i] from type Object to type Object[].  Having made the conversion, it then accesses the jth element of the array object whose reference is stored there (in order to assign a value to that element).

((Object[])v3[i])[j]= ...

Display data in leaf array objects

Listing 18 uses similar casts to get and display the values encapsulated in the Integer objects whose references are stored in the elements of the leaf array objects.
 

    for(int i=0;i<v3.length;i++){
      for(int j=0;
            j<((Object[])v3[i]).length;
                                  j++){
        System.out.print(
           ((Object[])v3[i])[j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop

Listing 18

The rectangular output

This approach produced the following output on the screen, (which is the same as the previous two approaches):

1 2 3
2 4 6

Ragged arrays

All the code in the previous three cases has been used to emulate a traditional rectangular two-dimensional array.  In the first case, each row was required to have the same number of elements by the syntax used to create the tree of array objects.

In the second and third cases, each row was not required to have the same number of elements, but they were programmed to have the same number of elements in order to emulate a rectangular two-dimensional array.

A triangular array, sort of ...

Now I am going to show you some cases that take advantage of the ragged-array capability of Java array objects.  In the next case, (beginning with Listing 19), I will create a ragged array having two rows.  The first row will have two elements and the second row will have three elements.  (This array object might be thought of as being sort of triangular.)
 

    Object[][] v4 = new Object[2][];
    v4[0] = new Object[2];
    v4[1] = new Object[3];

Listing 19

You have seen this before

You saw code like this before in the second case discussed earlier.  However, in that case, the second and third statements created new array objects having the same length.  In this case, the second and third statements create array objects having different lengths.  This is one of the ways to create a ragged array in Java (you will see another way in the next case that I will discuss).

Populate the leaf array objects

Listing 20 populates the elements of the leaf array objects with references to objects of the class Integer.
 

    for(int i=0;i<v4.length;i++){
      for(int j=0;j<v4[i].length;j++){
        v4[i][j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop

Listing 20

You have seen this before also

You have also seen the code in Listing 20 before.  I repeated it here because this case clearly emphasizes the value of the length constant that is available in all Java array objects.  In the earlier case, the length of the two leaf array objects was the same, so it would have been feasible to simply hard-code that value into the conditional expression of the inner for loop.

The length is not the same now

However, in this case, the length of the two leaf array objects is not the same.  Therefore, it wouldn't work to hard-code a limit into the conditional expression of the inner for loop.  However, because the length of each leaf array object is available as a public member of the array object, that value can be used to control the number of iterations of the inner loop for each separate leaf array object.

The triangular output

The next section of code in the program shown in Listing 26 near the end of the lesson uses the same code as before to display the int values encapsulated in the Integer objects whose references are stored in the leaf array objects.  Since it is the same code as before, I won't repeat it here.

The output produced by this case is shown below:

1 2
2 4 6

Note that this is not the same as before, and this output does not describe a rectangular array. Rather, it describes a ragged array where the rows are of different lengths.

(As I indicated earlier, it is sort of triangular.  However, it could be any shape that you might want it to be.)
A more general approach

The next case, shown in Listing 21, is the same as the third case discussed earlier, except that the lengths of the leaf array objects are not the same.

As before, this case creates a one-dimensional array object of type Object (having two elements) that forms the root of a tree.  Each element in the root object contains a reference to another array object of type Object.

One of those leaf objects has two elements and the other has three elements, thus producing a ragged array (you could make the lengths of those objects anything that you want them to be).
 

    Object[] v5 = new Object[2];
    v5[0] = new Object[2];
    v5[1] = new Object[3];

Listing 21

Populate the leaf objects

As before, the elements in the leaf array objects are populated with references to objects of the class Integer, which encapsulate int values based on the current value of the loop counters.  This is shown in Listing 22.
 

    for(int i=0;i<v5.length;i++){
      for(int j=0;
            j<((Object[])v5[i]).length;
                                  j++){
        ((Object[])v5[i])[j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop

Listing 22

Same code as before

This is the same code that you saw in Listing 17.  I repeated it here to emphasize the requirement for casting (shown in boldface in Listing 22).

Display the data

This case uses the same code as Listing 18 to display the int values encapsulated by the Integer objects whose references are stored in the elements of the leaf array objects.  I won't repeat that code here.

The triangular output

The output produced by this case is shown below:

1 2
2 4 6

Note that this is the same as the case immediately prior to this one.  Again, it does not describe a rectangular array. Rather, it describes a ragged array where the rows are of different lengths.

A more general case

I'm going to show you one more general case for a ragged array.  This case illustrates a more general approach.  In this case, I will create a one-dimensional array object of element type Object.  I will populate the elements of that array object with references to other array objects.  These array objects will be the leaves of the tree.

Leaf array objects are type int

In this case, the leaves won't be of element type Object.  Rather, the elements in the leaf objects will be designed to store primitive int values.

(An even more general case would be to populate the elements of the root object with references to a mixture of objects of class types, interface types, and array objects where the elements of the array objects are designed to store primitives of different types, and references of different types.  Note, however, each leaf array object must be designed to store a single type, but will accept for storage any type that is assignment-compatible with the specified type for the array object.)
This case begins in Listing 23, which creates the root array object, and populates its elements with references to leaf array objects of type int.
 
    Object[] v6 = new Object[2];
    v6[0] = new int[7];
    v6[1] = new int[3];

Listing 23

Leaf objects are different lengths

One of the leaf array objects has a length of 7.  The other has a length of 3.

Populate the leaf array elements

Listing 24 populates the elements in the leaf array objects with values of type int.
 

    for(int i=0;i<v6.length;i++){
      for(int j=0;
            j<((int[])v6[i]).length;
                                  j++){
        ((int[])v6[i])[j] = (i+2)*(j+2);
      }//end inner loop
    }//end outer loop

Listing 24

Similar to previous code

The code in Listing 24 is similar to code that you saw earlier.  The differences are:

  • Cast is to type int[] instead of object[] (see boldface code)
  • Values assigned are type int instead of references to Integer objects (see boldface Italic code)
Display the output

Finally, Listing 25 displays the int values stored in the elements of the leaf array objects.
 

    for(int i=0;i<v6.length;i++){
      for(int j=0;
            j<((int[])v6[i]).length;
                                  j++){
        System.out.print(
           ((int[])v6[i])[j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop

Listing 25

The code in Listing 25 is very similar to what you have seen before, and there should be no requirement for an explanation of this code.

The code in Listing 25 produces the following output:

4 6 8 10 12 14 16
6 9 12

I will leave it as an exercise for the student to correlate the output with the code.
 

Summary

When declaring a reference variable capable of referring to an array object, the array type is declared by writing the name of an element type followed by some number of empty pairs of square brackets [].

The components in an array object may refer to other array objects.  The number of bracket pairs used in the declaration of the reference variable indicates the depth of array nesting (in the sense that array elements can refer to other array objects).

An array's length is not part of its type or reference variable declaration.

Multi-dimensional arrays are not required to represent rectangles, cubes, etc.  They can be ragged.

The normal rules of type conversion and assignment compatibility apply when creating and populating array objects.

Object is the superclass of all other classes.  Therefore, an array of element type Object is capable of storing references to objects instantiated from any other class.  The type declaration for such an array object would be Object[].

An array of element type Object is also capable of storing references to any other array object.

If the declared element type for the array object is one of the primitive types, the elements of the array can be used to store values of any primitive type that is assignment compatible with the declared type (without the requirement for a cast).

If the declared element type is the name of a class, (which may or may not be abstract), a null reference or a reference to any object instantiated from the class or any subclass of the class may be stored in the array element.

If the declared element type is an interface type, a null reference or a reference to any object instantiated from any class that implements the interface can be stored in the array element.

A reference variable whose declared type is an array type does not contain an array.  Rather, it contains either null, or a reference to an array object.  Declaring the reference variable does not create an array, nor does it allocate any space for the array components.

It is possible to declare a reference to an array object and initialize it with a reference to an array object when it is declared.

A reference to an array object can refer to different array objects (of the same element type and different lengths) at different points in the execution of a program.

When declaring an array reference variable, the square brackets [] may appear as part of the type, or following the variable name, or both.

Once an array object is created, its type and length never changes.

An array object is created by an array creation expression or an array initializer.

An array creation expression (or an array initializer) specifies:

  • The element type
  • The number of levels of nested arrays
  • The length of the array for at least one of the levels of nesting
The length of the array is always available as a final instance variable named length.

An array element is accessed by an expression whose value is an array reference followed by an indexing expression enclosed by matching square brackets.

If an attempt is made to access the array with an invalid index value, an ArrayIndexOutOfBoundsException will be thrown.

Arrays must be indexed by integer values of the types int, short, byte, or char.  An array cannot be accessed using an index of type long.

If the elements in an array are not purposely initialized when the array is created, the array elements will be automatically initialized with default values.

The values in the array elements may be purposely initialized when the array object is created using a comma-separated list of expressions enclosed by matching curly braces.

The program in this lesson illustrated three different ways to emulate traditional rectangular two-dimensional arrays.

The program also illustrated two different ways to create and work with ragged arrays.

What's Next?

In the next lesson, I will provide so additional information about array objects, and then illustrate the use of the classes named Array and Arrays for the creation and manipulation of array objects.

Complete Program Listing

A complete listing of the program is shown in Listing 26 below.
 
/*File Array07.java
Copyright 2002, R.G.Baldwin

This program illustrates three 
different ways to emulate a traditional
rectangular array in Java.  Two of 
those ways are essentially ragged
arrays with equal-length sub arrays.

The program also illustrates two ways
to create ragged arrays in Java.

Tested using JDK 1.3 under Win 2000.
**************************************/

public class Array07{
  public static void main(
                        String[] args){

    //Create an array structure that
    // emulates a traditional 
    // rectangular array with two rows
    // and three columns.  This
    // approach requires all rows to
    // be the same length.
    Object[][] v1 = new Object[2][3];
    //Populate the array elements with
    // references to objects of type 
    // Integer.
    for(int i=0;i<v1.length;i++){
      for(int j=0;j<v1[i].length;j++){
        v1[i][j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v1.length;i++){
      for(int j=0;j<v1[i].length;j++){
        System.out.print(
                       v1[i][j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
    System.out.println();//new line   

    //Create a ragged array with two
    // rows.  The first row has three
    // columns and the second row has
    // three columns.  The length of
    // each row could be anything, but
    // was set to three to match the
    // above array structure.
    Object[][] v2 = new Object[2][];
    v2[0] = new Object[3];
    v2[1] = new Object[3];
    //Populate the array elements with
    // references to objects of type 
    // Integer.
    for(int i=0;i<v2.length;i++){
      for(int j=0;j<v2[i].length;j++){
        v2[i][j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v2.length;i++){
      for(int j=0;j<v2[i].length;j++){
        System.out.print(
                       v2[i][j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
    System.out.println();//new line

    //Create a one-dimensional array
    // of type Object, which contains
    // references to array objects of 
    // type Object.  The secondary
    // array objects could be of any
    // length, but were set to three
    // to match the above array 
    // structure.
    Object[] v3 = new Object[2];
    v3[0] = new Object[3];
    v3[1] = new Object[3];
    //Populate the array elements with
    // references to objects of type 
    // Integer.
    for(int i=0;i<v3.length;i++){
      for(int j=0;
            j<((Object[])v3[i]).length;
                                  j++){
        ((Object[])v3[i])[j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v3.length;i++){
      for(int j=0;
            j<((Object[])v3[i]).length;
                                  j++){
        System.out.print(
           ((Object[])v3[i])[j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
    System.out.println();//new line

    //Create a ragged array with two
    // rows.  The first row has two
    // columns and the second row has
    // three columns.
    Object[][] v4 = new Object[2][];
    v4[0] = new Object[2];
    v4[1] = new Object[3];
    //Populate the array elements with
    // references to objects of type 
    // Integer.
    for(int i=0;i<v4.length;i++){
      for(int j=0;j<v4[i].length;j++){
        v4[i][j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v4.length;i++){
      for(int j=0;j<v4[i].length;j++){
        System.out.print(
                       v4[i][j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
    System.out.println();//new line

    //Create a one-dimensional array
    // of type Object, which contains
    // references to array objects of 
    // type Object.  The secondary
    // array objects could be of any
    // length, but were set to two and
    // three to match the ragged array 
    // above.
    Object[] v5 = new Object[2];
    v5[0] = new Object[2];
    v5[1] = new Object[3];
    //Populate the array elements with
    // references to objects of type 
    // Integer.
    for(int i=0;i<v5.length;i++){
      for(int j=0;
            j<((Object[])v5[i]).length;
                                  j++){
        ((Object[])v5[i])[j] = 
              new Integer((i+1)*(j+1));
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v5.length;i++){
      for(int j=0;
            j<((Object[])v5[i]).length;
                                  j++){
        System.out.print(
           ((Object[])v5[i])[j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
    System.out.println();
   
    //Create a one-dimensional array
    // of type int, which contains
    // references to array objects of 
    // type Object.  The secondary
    // array objects could be of any
    // length.
    Object[] v6 = new Object[2];
    v6[0] = new int[7];
    v6[1] = new int[3];
    //Now illustrate that the elements
    // of the leaves of a ragged array
    // implemented in this manner can
    // contain primitive values.
    // Populate the array elements with
    // type int.
    for(int i=0;i<v6.length;i++){
      for(int j=0;
            j<((int[])v6[i]).length;
                                  j++){
        ((int[])v6[i])[j] = (i+2)*(j+2);
      }//end inner loop
    }//end outer loop
    //Display the array elements
    for(int i=0;i<v6.length;i++){
      for(int j=0;
            j<((int[])v6[i]).length;
                                  j++){
        System.out.print(
           ((int[])v6[i])[j] + " ");
      }//end inner loop
      System.out.println();//new line
    }//end outer loop
   
  }//end main
}//end class Array07
//===================================//

Listing 26


About the author

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java and XML. In addition to the many platform-independent benefits of Java applications, he believes that a combination of Java and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving Java, XML, or a combination of the two.  He frequently provides onsite Java and/or XML training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Java Programming Tutorials, which has gained a worldwide following among experienced and aspiring Java programmers. He has also published articles on Java Programming in Java Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

# # #

Sitemap | Contact Us

Thanks for your registration, follow us on our social networks to keep up-to-date