Section 8.1
Creating and Using Arrays
WHEN A NUMBER OF DATA ITEMS are chunked together
into a unit, the result is a data
structure. Data structures can have
very complex structure, but in many applications, the appropriate
data structure consists simply of a sequence of data items. Data structures of this
simple variety can be either arrays
or records.
The term "record" is not used in Java. A record is
essentially the same as a Java object that has instance variables
only, but no instance methods. Some other languages, which do
not support objects in general, nevertheless do support records.
The C programming language, for example, is not object-oriented,
but it has records, which in C go by the name "struct."
The data items in a record -- in Java, an object's instance variables --
are called the fields of the record.
Each item is referred to using a field
name. In Java, field names are just the names of the instance
variables. The distinguishing characteristics of a record are that the
data items in the record are referred to by name and that different
fields in a record are allowed to be of different types. For
example, if the class Person is defined as:
class Person {
String name;
int id_number;
Date birthday;
int age;
}
then an object of class Person could be considered to
be a record with four fields. The field names are name,
id_number, birthday, and age. Note that
the fields are of various types: String, int,
and Date.
Because records are just a special type of object, I will not
discuss them further.
Like a record, an array is a sequence of items. However,
where items in a record are referred to by name,
the items in an array are numbered, and individual items are
referred to by their position number. Furthermore,
all the items in an array must be of the same type. The definition
of an array is: a numbered sequence of items, which are all
of the same type. The number of items in an array is called the
length of the array. The position
number of an item in an array is called the index
of that item. The type of the individual items in an array is
called the base type of the array.
The base type of an array can be any Java type, that is, one
of the primitive types, or a class name, or an interface name.
If the base type of an array is int, it is referred to
as an "array of ints." An array with base type
String is referred to as an "array of Strings."
However, an array is not, properly speaking, a list of integers
or strings or other values. It is better thought
of as a list of variables of type int,
or of type String, or of some other type. As always,
there is some potential for confusion between the two uses of
a variable: as a name for a memory location and as a name for
the value stored in that memory location. Each position in an
array acts as a variable. Each position can hold a value of
a specified type (the base type of the array). The value
can be changed at any time. Values are stored in
an array. The array is the container, not the values.
The items in an array -- really, the individual variables that
make up the array -- are more often referred to as the
elements of the array.
In Java, the elements in an array are always numbered starting from zero.
That is, the index of the first element in the array is zero. If the length
of the array is N, then the index of the last element in
the array is N-1. Once an array has been created, its
length cannot be changed.
Java arrays are objects. This has several
consequences. Arrays are created using a form of the new operator.
No variable can ever hold an array; a variable
can only refer to an array. Any variable that
can refer to an array can also hold the value null,
meaning that it doesn't at the moment refer to anything. Like any
object, an array belongs to a class, which like all classes
is a subclass of the class Object. The elements of
the array are, essentially, instance variables in the array object,
except that they are referred to by number rather than by name.
Nevertheless, even though arrays are objects, there are differences
between arrays and other kinds of objects, and there are a number
of special language features in Java for creating and using
arrays.
Suppose that A is a variable that refers to an array.
Then the item at index k in A is referred to
as A[k]. The first item is A[0], the second is
A[1], and so forth. "A[k]" is really
a variable, and it can be used just like any other variable.
You can assign values to it, you can use it
in expressions, and you can pass it as a parameter to subroutines.
All of this will be discussed in more detail below. For now,
just keep in mind the syntax
array-variable
[ integer-expression ]
for referring to an element of an array.
Although every array, as an object, is a member of some class, array
classes never have to be defined. Once a type exists, the corresponding
array class exists automatically. If the name of the type
is BaseType, then the name of the associated array class
is BaseType[]. That is to say, an object belonging to the
class BaseType[] is an array of items, where each
item is a variable of type BaseType. The brackets,
"[]", are meant to recall the syntax for
referring to the individual items in the array.
"BaseType[]" is read as "array
of BaseType" or "BaseType array."
It might be worth mentioning here that if ClassA is a subclass of
ClassB, then ClassA[] is automatically
a subclass of ClassB[].
The base type of an array can be any legal Java type. From the primitive
type int, the array type int[] is derived.
Each element in an array of type int[] is a variable of
type int, which holds a value of type int.
From a class named Shape,
the array type Shape[] is derived. Each item in
an array of type Shape[] is a variable of type Shape,
which holds a value of type Shape. This value
can be either null or a reference to an object
belonging to the class Shape. (This includes objects
belonging to subclasses of Shape.)
Let's try to get a little more concrete about all this,
using arrays of integers as our first example. Since int[]
is a class, it can be used to declare variables. For example,
int[] list;
creates a variable named list of type int[].
This variable is capable of referring to an array of ints,
but initially its value is null (if it is a member variable in
a class) or undefined (if it is a local variable in a method).
The new operator is used to create a new array object, which can
then be assigned to list. The syntax for
using new with arrays is different from the
syntax you learned previously. As an example,
list = new int[5];
creates an array of five integers. More generally, the constructor
"new BaseType[N]" is used to create an array belonging
to the class BaseType[]. The value N in brackets
specifies the length of the array, that is, the number of elements that
it contains. Note that the array "knows" how long it is.
The length of the array is an instance variable
in the array object. In fact, the length of an array,
list, can be referred to as list.length.
(However, you are not allowed to change the value of
list.length, so it's really a "final" instance
variable, that is, one whose value cannot be changed after it has been
initialized.)
The situation produced by the statement
"list = new int[5];" can be pictured like
this:
Note that the newly created array of integers is automatically
filled with zeros. In Java, a newly created array is always
filled with a known, default value: zero for numbers,
false for boolean, the character with Unicode
number zero for char, and null for objects.
The elements in the array, list,
are referred to as list[0], list[1],
list[2], list[3], and list[4]. (Note again
that the index for the last item is one less than list.length.)
However, array references can be much more general than this.
The brackets in an array reference can contain any expression
whose value is an integer. For example if indx is a variable
of type int, then list[indx] and list[2*indx+7]
are syntactically correct references to elements of the array list.
Thus, the following loop would print all the integers in the
array, list, to standard output:
for (int i = 0; i < list.length; i++) {
System.out.println( list[i] );
}
The first time through the loop, i is 0, and list[i]
refers to list[0]. So, it is the value stored in the variable
list[0] that is printed.
The second time through the loop, i is 1,
and the value stored in list[1] is printed.
The loop ends after printing the value of list[4],
when i becomes equal to 5
and the continuation condition "i<list.length"
is no longer true. This is a typical example of using a loop
to process an array. I'll discuss more examples of array
processing throughout this chapter.
Every use of a variable in a program specifies a memory location.
Think for a moment about what the computer does
when it encounters a reference to an array element,
list[k], while it is executing a program.
The computer must determine which memory location is being
referred to.
To the computer, list[k] means something like this:
"Get the pointer that is stored in the variable, list.
Follow this pointer to find an array object. Get the value of
k. Go to the k-th position in the array, and that's
the memory location you want." There are two things that can go wrong here.
Suppose that the value of list is null.
If that is the case, then list doesn't even refer
to an array. The attempt to refer to an element of an
array that doesn't exist is an error. This is an example of
a "null pointer" error. The second possible error occurs
if list does refer to an array, but the value of
k is outside the legal range of indices for that
array. This will happen if k < 0 or if
k >= list.length. This is
called an "array index out of bounds" error.
When you use arrays in a program, you should be mindful that
both types of errors are possible. However, array index out of
bounds errors are by far the most common error when working with
arrays.
For an array variable, just as for any variable, you can
declare the variable and initialize it in a single step.
For example,
int[] list = new int[5];
If list is a local variable in a subroutine, then
this is exactly equivalent to the two statements:
int[] list;
list = new int[5];
(If list is an instance variable, then of course you
can't simply replace "int[] list = new int[5];" with
"int[] list; list = new int[5];" since the assignment
statement "list = new int[5];" is only legal inside a
subroutine.)
The new array is filled with the default value appropriate
for the base type of the array -- zero for int and
null for class types, for example. However, Java
also provides a way to initialize an array variable with
a new array filled with a specified list of values. In
a declaration statement that creates a new array, this
is done with an array initializer.
For example,
int[] list = { 1, 4, 9, 16, 25, 36, 49 };
creates a new array containing the seven values 1, 4, 9, 16,
25, 36, and 49, and sets list to refer to that new array.
The value of list[0] will be 1, the value of list[1]
will be 4, and so forth. The length of list is seven,
since seven values are provided in the initializer.
An array initializer takes the form of a list of values,
separated by commas and enclosed between braces. The length
of the array does not have to be specified, because it is
implicit in the list of values. The items in an array initializer
don't have to be constants. They can be variables or arbitrary expressions,
provided that their values are of the appropriate type.
For example, the following declaration creates an array of eight
Colors. Some of the colors are given by expressions of
the form "new Color(r,g,b)":
Color[] palette =
{
Color.black,
Color.red,
Color.pink,
new Color(0,180,0), // dark green
Color.green,
Color.blue,
new Color(180,180,255), // light blue
Color.white
};
A list initializer of this form can be used only in a declaration
statement, to give an initial value to a newly declared array
variable. It cannot be used in an assignment statement to assign a
value to a variable that has been previously declared.
However, there is another, similar notation for creating a new array
that can be used in an assignment statement or passed as a parameter
to a subroutine. The notation uses another form of the new operator
to create and initialize a new array object.
(This rather odd syntax is reminiscent of the syntax for anonymous classes, which
were discussed in Section 5.6.)
For example to assign a new value to an array
variable, list, that was declared previously, you
could use:
list = new int[] { 1, 8, 27, 64, 125, 216, 343 };
The general syntax for this form of the new operator is
new base-type [ ] { list-of-values }
This is an expression whose value is an array object. It can be used in any
context where an object of type base-type[] is expected.
For example, if makeButtons is a method that takes an array
of Strings as a parameter, you could say:
makeButtons( new String[] { "Stop", "Go", "Next", "Previous" } );
One final note: For historical reasons, the declaration
int[] list;
can also be written as
int list[];
which is a syntax used in the languages C and C++.
However, this alternative syntax does not really make much
sense in the context of Java, and it is probably best
avoided. After all, the intent is to declare a variable
of a certain type, and the name of that type is "int[]".
It makes sense to follow the
"type-name
variable-name;" syntax
for such declarations.
