Java Unit 9: ArraysDeclaring and Processing Arrays

What are arrays?• Arrays are ordered collections of data items that are all of the

same type. Using subscript notation an array with the name a would take this form:• (a0, a1, …, ai, …, an-1)

What are arrays?• Each element of the array could contain a value, such as a

double.• The elements are identified by the order in which they appear

in the array.• In computer science, it is customary to start with 0.

Element #: 0 1 2 3

Value: 3.2 12.0 4.3 0.1

Constructing arrays• Arrays in Java are objects, constructed like this:• double[] myArray;

myArray = new double[10];• In this declaration, ‘double’ is the type of value that all of the

elements in the array will be.• The brackets after ‘double’ indicates that this variable is an

array.• In the assignment, we use the keyword new, followed by the

type with brackets. In the brackets, the number of elements in the array is defined. In this case, it’s 10.

• You could also say the array has a size of 10.

Constructing arrays• As usual, you can declare and assign in a single line.• double[] myArray = new double[10];

Accessing arrays• Once an array has been constructed, it’s elements can be

accessed using an integer index value in square brackets.• The element of the array, a subscripted variable, can be used

like any other variable that is the same type as the array.• myArray[0] = 25.2;

double myVar = myArray[0];System.out.println(myArray[0]);

Array indexing• Arrays start at the 0th element.• So if an array of size 10 is declared, it’s indexing runs from 0 to

9.• Ignoring element 0 may or may not be a mistake, but you can

not access myArray[10], because it goes outside the array.• It’s similar to how a string object indexes its characters.

0 1 2 3 4 5 6 7 8 9

2.3 1.1 4.5 3.9 0.2 2.4 2.5 8.3 5.2 2.5

0 1 2 3 4

H E L L O

Array Types• It is possible to declare arrays containing simple types and

object references:• int[], double[], boolean[], String[]

• Although local variables do not have initialization in general, array contents have default initialization regardless of where they are declared or how they are used.• Numerics are 0 by default• Booleans are false by default• Object references are null by default

main(String[] args)• Consider this line of code that appears in every program:• public static void main(String[] args)

• We can see that it takes an array of Strings as a parameter. • If this program is run from the command line, multiple

command line arguments can be entered on the same line that executes the program, with each argument separated by a string:• java MyJava.class myArg1 myArg2 myArg3

• The command line arguments would be stored inside an array, and passed into the main() method as ‘args’.

Arrays and Objects• An array can be declared to contain objects of any kind of

object.• Cup[] myCups = new Cup[10]; //An array of 10 Cup object

references• As usual, the class name is capitalized.• The name of the array is a reference to a constructed object,

so it is not capitalized.• If we index a single element in the object array, we can call

methods on them like any other object.• int myCount = myCups[3].getSeedCount();

Arrays and Loops• Loops are incredibly useful in processing arrays.• Since the elements of arrays can be identified by consecutive

integers, it is a simple matter to use the loop index as the array index:• for(int j = 0; j < 10; j++) {

myArray[j] = j * j;}

• The initial value of j is 0, the beginning element of the array.• The last value of j is 9, so it stops before it refers to a non-existent

element.• We could have written the looping condition as j <= 9, but there is

a logic to using strict inequality and the size of the array, explained on the next slide.

Arrays and Loops• Because the size of arrays is needed so often, Java has

provided the means to obtain it:• myArray.length• This returns the number of elements for that array• Note that in this case there is no parenthesis, nor is there a

method called getLength()• ‘length’ is actually a ‘public final’ instance variable. We can access

this variable because it is public.• Using the size of the array itself instead of a hard-coded value,

processing the entire array becomes this:• for(int j = 0; j < myArray.length; j++) {

myArray[j] = j * j;}

Arrays and Loops• Arrays can be traversed in loops in either direction.• To access the array from the last element to first, the starting

and stopping variables of the index have to be set accordingly.• for(int j = myArray.length – 1; j >= 0; j--) {…}

Arrays are fixed in size• It is important to note that just like with any other data item,

an array can only be declared once. • In that one declaration, its size, the number of elements in the

array is fixed. • The size cannot be changed later on during the course of a

program run.• This makes it necessary to anticipate the largest number of

elements that might ever be needed and declare the size of the array accordingly.

• This may mean that a large number of positions in the array will remain unused.

Multi-dimensional arrays• Arrays of more than one dimension can be declared.• Two dimensional arrays, or matrices, can be represented as a

table of values, which is m x n in size.• For both dimensions, indexing starts at 0 as usual.• This means that indexing goes up to m – 1 for the rows, and n

– 1 for columns.

N, M N = 0 N = 1 N = 2 N = 3

M = 0 0, 0 1, 0 2, 0 3, 0

M = 1 0, 1 1, 1 2, 1 3, 1

M = 2 0, 2 1, 2 2, 2 3, 2

Multi-dimensional arrays• The first subscript of an element represents its row and the

second represents its column.• The declaration of such an in Java, if it contained integer

elements and 4 rows and 5 columns, would take this form:• int[][] myIntArray = new int[4][5];

• The parts of the declaration of this array are analogous to the corresponding parts for a one dimensional array. The only difference is that two sets of square brackets are used, the first indicating the rows, and the second the columns.

Accessing Multi-dimensional arrays• Individual elements are accessed by specifying the index

values for the row and column in square brackets. For example:• myIntArray[2][4] = 95;

• Two dimensional arrays can be processed conveniently using nested for loops. Just as with one dimensional arrays, array indexing starts at 0 and the lengths of the dimensions can be used to set limits on the loop indexes. This introduces a slight complexity.

Accessing Multi-dimensional arrays• for(int i = 0; i < myIntArray.length; i++) {

for(int j = 0; j < myIntArray[0].length; j++){

…}

}• myIntArray.length gives the number of rows in myIntArray• myIntArray[0].length gives the number of columns in the 0th

row (or any row) of myIntArray

Accessing Multi-dimensional arrays• A two dimensional array is really a one dimensional array of

references to a set of one dimensional arrays. In other words, it’s an array of arrays.

• The value of the length returned for the name of the array alone is the number of rows, or the number of one dimensional arrays it contains.

• If the name of a two dimensional array is given with a single set of brackets, this represents a single row.

• The length of one row is the number of columns in the two dimensional array.

• Syntactically, the use of square brackets to specify the dimensions is analogous to the two dimensional case.

• The underlying reality is that a three dimensional array is an array of arrays of arrays, and so on for higher dimensions.