java programming: from problem analysis to program design, 3e chapter 9 arrays

Java Programming: From Problem Analysis to Program Design, 3e

Chapter 9

Arrays

Chapter Objectives

• Learn about arrays

• Explore how to declare and manipulate data into arrays

• Understand the meaning of “array index out of bounds”

• Become familiar with the restrictions on array processing

Chapter Objectives (continued)

• Discover how to pass an array as a parameter to a method

• Discover how to manipulate data in a two-dimensional array

• Learn about multidimensional arrays

Array

• Definition: structured data type with a fixed number of elements

• Elements of an array are also called components of the array

• Every element is of the same type

• Elements are accessed using their relative positions in the array

One-Dimensional Arrays

One-Dimensional Arrays (continued)

One-Dimensional Arrays (continued)

•intExp = number of components in array >= 0•0 <= indexExp <= intExp

• Array num:int[] num = new int[5];

Arrays

Array List

Array List (continued)

Specifying Array Size During Program Execution

• The initializer list contains values, called initial values, that are placed between braces and separated by commas

• Here, sales[0]= 12.25, sales[1]= 32.50, sales[2]= 16.90, sales[3]= 23.00, and sales[4]= 45.68

Array Initialization During Declaration

Using Initializer Lists

• When declaring and initializing arrays, the size of the array is determined by the number of initial values within the braces

• If an array is declared and initialized simultaneously, we do not use the operator new to instantiate the array object

• Associated with each array that has been instantiated, there is a public (final) instance variable length

• The variable length contains the size of the array • Do NOT confuse this with the length() method used

in strings. With arrays, length is a field.• The variable length can be directly accessed in a

program using the array name and the dot operator

Arrays and the Instance Variable length

Arrays and the Instance Variable length (continued)

int[] list = {10, 20, 30, 40, 50, 60};

• This statement creates the array list of six components and initializes the components using the values given– list.length is 6

int[] numList = new int[10];

• This statement creates the array numList of 10 components and initializes each component to 0

• The value of numList.length is 10 numList[0] = 5;numList[1] = 10;numList[2] = 15;numList[3] = 20;

• These statements store 5, 10, 15, and 20, respectively, in the first four components of numList

• You can store the number of filled elements, that is, the actual number of elements, in the array in a variable, say numOfElement

• When dealing with an array that is only partially filled, it is good programming practice for your program to keep track of the number of filled elements in an array (i.e. use a variable)

Arrays and the Instance Variable length (continued)

Repeat: Keeping Track of Length

• Again: So far we’ve dealt only with arrays that we assume are filled with valid data. However it’s important to recognize that we will often (perhaps mostly) be dealing with arrays that are only partially filled with meaningful information. In these situations, we must have a variable that keeps track of how much of our array is “relevant”.

• This way, when we loop, we will NOT loop from i=0 until i < array.length.

• Instead we will loop from i=0 until

i < variable_keeping_track_of_array

• Loops used to step through elements in array and perform operations

int[] list = new int[100];int i;

for (i = 0; i < list.length; i++) //process list[i], the (i + 1)th //element of list

for (i = 0; i < list.length; i++) list[i] = console.nextInt();

for (i = 0; i < list.length; i++) System.out.print(list[i] + " ");

Processing One-Dimensional Arrays

Arrays (continued) • Some operations on arrays:

– Initialize (e.g. set all values to -1)– Input data (e.g. from a file, from the user)– Output stored data – Find largest/smallest/sum/average of elements– Etc…

double[] arrSales = new double[10];int index;double largestSale, sum, average;

Code to Initialize Array to Specific Value (10.00)

for (index = 0; index < arrSales.length; index++) arrSales[index] = 10.00;

Code to Read Data into Array

for (index = 0; index < arrSales.length; index++) arrSales[index] = console.nextDouble();

Code to Print Array

for (index = 0; index < arrSales.length; index++) System.out.print(arrSales[index] + " ");

Code to Find Sum and Average of Array

sum = 0;for (index = 0; index < arrSales.length; index++) sum = sum + arrSales[index];

if (arrSales.length != 0) average = sum / arrSales.length;else average = 0.0;

Determining Largest Element in Array

maxIndex = 0;

for (index = 1; index < arrSales.length; index++) if (arrSales[maxIndex] < arrSales[index]) maxIndex = index;//Note: no need for braces here

largestSale = arrSales[maxIndex];

Determining Largest Element in Array (continued)

Array Index Out of Bounds

• Array in bounds if:0 <= index <= arraySize – 1

• If index < 0 or index > arraySize:

ArrayIndexOutOfBoundsException exception is thrown

We will discuss exceptions in a later lecture

• Base address: memory location of first component in array

The Assignment Operators and Arrays

Supposing I were to write: listB = listA; ?

The Assignment Operators and Arrays (continued)

Relational Operators Arrays

• if (listA == listB) Will this work?- The expression listA == listB determines if the values of listA and listB are the same and thus determines whether listA and listB refer (point) to the same array- To determine whether listA and listB contain the same elements, you need to compare them element by element- You can write a method that returns true if two int arrays contain the same elements

* Relational Operators and Arrays (continued)

boolean isEqualArrays(int[] firstArray, int[] secondArray){ if (firstArray.length != secondArray.length) return false; //could save us time!

for (int index = 0; index < firstArray.length; index++) if (firstArray[index] != secondArray[index]) return false; return true;}

if (isEqualArrays(listA, listB))...

* Arrays as Parameters to Methods

In this second method, we don’t use the field ‘length’. You would want to do this in a situation where you have an array that is not completely filled. (e.g. only 10 elements of an array of size 20 has meaningful values)

//Why the extra parameter to this method?

Methods for Array Processing

Methods for Array Processing (continued)

* Arrays of Objects (important)• Can use arrays to manipulate objects• Example: create array named records with 20 objects

of type StudentRecord: StudentRecord[] records = new StudentRecord[20]

• Can fill records with instances of StudentRecord objects as follows:

for(int j=0; j <records.length; j++)

records[j] = new StudentRecord();

Array of String Objects

String[] nameList = new String[5];

nameList[0] = "Amanda Green";

nameList[1] = "Vijay Arora";

nameList[2] = "Sheila Mann";

nameList[3] = "Rohit Sharma";

nameList[4] = "Mandy Johnson";

Array of String Objects (continued)

* Do not confuse the array as a whole with individual elements

• Consider the nameList[] array from the previous slide. If I were to ask you the data-type of nameList, many of you would be tempted to say ‘String’ or ‘array’. Yet neither is correct. The correct answer is “an array of String objects’

• If I were to ask you the data type of nameList[0] however, it is vitally important that you recognize that the answer is String.

For example• How might you check to see if the first element of the array is “Robert”?

if ( nameList[0].equals(“Robert”) ) { ...• How might you check to see if the first two elements of the array are identical?

if ( nameList[0].equals( nameList[1] ) ) { ...• How might you check the length of the last element of the array?

if ( nameList[namelist.length -1].length() ) { ...

Arrays of Objects contdYour book gives an example class called ‘Clock’ that has fields to represent hours, minutes and seconds:

public class Clock{ private int hr; //store hours private int min; //store minutes private int sec; //store seconds etc....

Suppose you had 100 employees who are paid on an hourly basis and you want to keep track of their arrival and departure times. You could create an array of 100 Clock objects to represent their arrival times, and also have an additional array of 100 Clock objects to represent their departure times.

Clock[] arrivalTimeEmp = new Clock[100];

Arrays of Objects (continued)

Instantiating Array Objectsfor (int j = 0; j < arrivalTimeEmp.length; j++) arrivalTimeEmp[j] = new Clock();

arrivalTimeEmp[49].setTime(8, 5, 10);

Instantiating Array Objects (continued)

Array of objects continued

The toString() method has been written (overridden) for the class

You could output all of the information for each employee in the usual way:

for (int i=0; i<arrivalTimeEmp.length; i++) System.out.print( arrivalTimeEmp[i] );

… as long as?????

Arrays and Variable Length Parameter List

• The syntax to declare a variable length formal parameter (list) is:

dataType ... identifier

We will skip this section for 212. This is for your interest only at this point. Skip to the slide on the ‘foreach’ loop

Arrays and Variable Length Parameter List (continued)


• A method can have both a variable length formal parameter and other formal parameters; consider the following method heading: public static void myMethod(String name, double num, int ... intList)

• The formal parameter name is of type String, the formal parameter num is of type double, and the formal parameter intList is of variable length

• The actual parameter corresponding to intList can be an int array or any number of int variables and/or int values


• A method can have at most one variable length formal parameter

• If a method has both a variable length formal parameter and other types of formal parameters, then the variable length formal parameter must be the last formal parameter of the formal parameter list

* for-each loop

• A nice shortcut for iterating through arrays– Only in more recent versions of Java (> version 5.0)

• The syntax to use this for loop to process the elements of an array is:

for (dataType identifier : arrayName) statements

• The data type of identifier must be the same as the data type of the components in the array

for-each loop example

Read the colon as “in”. In the example below, we are saying for each ‘s’ in ‘names’…

for (String s : names){ System.out.println(s);}

How the foreach loop works

total = 0; for (double num : list) total = total + num;

• The for statement in Line 2 is read as: for each num in list• The identifier num is initialized to list[0]• In the next iteration, the value of num is list[1], and so onfor (double num : numList){ if (max < num) max = num;}


for (double number : numbers){ System.out.println(number);}

Suppose you had an array called ‘numbers’ that is filled with doubles and wanted to output them using a foreach loop:


for (StudentRecord student : records){ System.out.println(student);}

Suppose you had an array of StudentRecords called ‘records’ and wanted to output them using a foreach loop:

(Note that toString() must be implemented in the StudentRecord class for the output to work properly.)

Limitations of the for-each loop

• The iterator (e.g. the ‘i’ that we are used to) is hidden in a for-each loop. So if you need to keep track of a specific index, for example, then this may not be your best choice of iterator. – You could declare a separate variable and increment it inside the body of

your loop, but in that case, you might as well just go with a regular for loop.

• Making changes to the array is not easily done either. For example, how would you increment each element of an integer array by +1? (Try it…)

• That being said, the for-each loop is extremely small, clear, and elegant. You should use it when possible!

Two-Dimensional ArraysSo far we have used arrays to store lists of data. What if, instead of a plain list, we wanted to keep track of something more like a table? For example, suppose you are a automobile dealer and you have an inventory that includes several BMWs, Toyotas, GMs, etc. In addition, for each make, you have several different colors. (For our example, the book assumes that each company sells only one type of model of each make!) So, for each make, we want to know how many red / brown / black / white / gray of each we have. This kind of data is best represented by a table as shown on the next slide.

Any kind of data that is best formed as a table, should probably be represented by a two-dimensional array.

We will create a two-dimensional array called inStock that keeps track of 6 different makes (GM, Ford, etc) and 5 different colors. The syntax to create such an array would be:int[][] inStock = new int[5][6];// Create a 2-D array of 5 rows, with 6 cells per row// NOTE: First index = ROW, second = COLUMN

Two-Dimensional Arrays

inStock[0][1] holds 7 inStock[4][2] holds 12

Two-Dimensional Arrays (continued)

double[][] sales = new double[10][5];//e.g. keep track of 10 employees over 4 months

Two-Dimensional Arrays (continued)

• intExp1, intExp2 >= 0• indexExp1 = row position• indexExp2 = column position

Accessing Array Elements

Accessing Array Elements (continued)

• This statement declares and instantiates a two-dimensional array matrix of 20 rows and 15 columns

• The value of the expression:matrix.length is 20, the number of rows

• So how do you think you would determine the number of columns?

• Answer: matrix[0].length

Two-Dimensional Arrays and the Instance Variable length

Two-Dimensional Arrays and the Instance Variable length (continued)

• Each row of matrix is a one-dimensional array; matrix[0], in fact, refers to the first row

• The value of the expression:matrix[0].lengthis 15, the number of columns in the first row

• matrix[1].length gives the number of columns in the second row, which in this case is 15, and so on

Two-Dimensional (“Ragged”) Arrays:Different Number of columns in each row

•Create columns

int[][] board = new int[5][]

Two-Dimensional Arrays: Special Cases:Different Number of columns in each row

Such arrays are known as “ragged” arrays

Two-Dimensional Array Initialization During Declaration

• To initialize a two-dimensional array when it is declared

- The elements of each row are enclosed within braces and separated by commas- All rows are enclosed within braces

Two-Dimensional Array Initialization During Declaration (continued)

Two-Dimensional Arrays: Special Cases:Initialization During Declaration

Processing Two-Dimensional Arrays• We will assume that our arrays are not ragged

– Keeps things simple for now

• Three ways to process 2-D arrays– Entire array– Particular row of array (row processing)– Particular column of array (column processing)

• Processing algorithms is similar to processing algorithms of one-dimensional arrays– BUT: We will need to nest our loops.

Two-Dimensional Arrays: Processing

Initialization

for (row = 0; row < matrix.length; row++) for (col = 0; col < matrix[row].length; col++) matrix[row][col] = 10;

Printfor (row = 0; row < matrix.length; row++){ for (col = 0; col < matrix[row].length; col++) System.out.printf("%7d", matrix[row][col]); System.out.println();}

Inputfor (int row = 0; row < matrix.length; row++){ for (int col = 0; col < matrix[row].length; col++) matrix[row][col] = console.nextInt();}

Sum by Rowfor (row = 0; row < matrix.length; row++){ sum = 0; for (col = 0; col < matrix[row].length; col++) sum = sum + matrix[row][col]; System.out.println("Sum of row " + (row + 1) + " = "+ sum);}

Two-Dimensional Arrays: Processing (continued)

Sum by Column for (col = 0; col < matrix[0].length; col++){ sum = 0; for (row = 0; row < matrix.length; row++) sum = sum + matrix[row][col]; System.out.println("Sum of column " + (col + 1) + " = " + sum);}


Largest Element in Each Row

for (row = 0; row < matrix.length; row++){ largest = matrix[row][0]; for (col = 1; col < matrix[row].length; col++) { if (largest < matrix[row][col]) largest = matrix[row][col]; } System.out.println("The largest element of row " + (row + 1) + " = " + largest);}


Largest Element in Each Column

for (col = 0; col < matrix[0].length; col++){ largest = matrix[0][col]; for (row = 1; row < matrix.length; row++) if (largest < matrix[row][col]) largest = matrix[row][col]; System.out.println("The largest element of col " + (col + 1) + " = " + largest);}


Multidimensional Arrays

• Can define three-dimensional arrays or n-dimensional array (n can be any number)

• Syntax to declare and instantiate array

dataType[][]…[] arrayName = new dataType[intExp1][intExp2]…[intExpn];

• Syntax to access component

arrayName[indexExp1][indexExp2]…[indexExpn]

• intExp1, intExp2, ..., intExpn = positive integers• indexExp1,indexExp2, ..., indexExpn = non-negative integers

Loops to Process Multidimensional Arrays

double[][][] carDealers = new double[10][5][7];

for (i = 0; i < 10; i++) for (j = 0; j < 5; j++) for (k = 0; k < 7; k++) carDealers[i][j][k] = 10.00;

java programming: from problem analysis to program design, 3e chapter 9 arrays

Documents