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 num: int[] num = new int[5];

Array List

Array List (continued)

Array List (continued)

Array List (continued)

Specifying Array Size During Program Execution

Array Initialization During Declaration 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

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

Arrays and the Instance Variable length 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 (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

Arrays and the Instance Variable length (continued) 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)

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

Processing One-Dimensional Arrays 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 list[i] = console.nextInt(); System.out.print(list[i] + " ");

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; System.out.print(arrSales[index] + " ");

Code to Find Sum and Average of Array 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)

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)

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 true; } if (isEqualArrays(listA, listB)) ...

* Arrays as Parameters to Methods //Why the extra parameter to this method? 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)

Methods for Array Processing

Methods for Array Processing (continued)

Methods for Array Processing (continued)

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 contd Your 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) Clock[] arrivalTimeEmp = new Clock[100];

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

Instantiating Array Objects (continued) arrivalTimeEmp[49].setTime(8, 5, 10);

Array of objects continued 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????? The toString() method has been written (overridden) for the class

Arrays and Variable Length Parameter List 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 The syntax to declare a variable length formal parameter (list) is: dataType ... identifier

Arrays and Variable Length Parameter List (continued)

Arrays and Variable Length Parameter List (continued)

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

Arrays and Variable Length Parameter List (continued) 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 on for (double num : numList) { if (max < num) max = num; }

for-each loop example Suppose you had an array called ‘numbers’ that is filled with doubles and wanted to output them using a foreach loop: for (double number : numbers) { System.out.println(number); }

for-each loop example Suppose you had an array of StudentRecords called ‘records’ and wanted to output them using a foreach loop: for (StudentRecord student : records) { System.out.println(student); } (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 Arrays So 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)

Two-Dimensional Arrays (continued) double[][] sales = new double[10][5]; //e.g. keep track of 10 employees over 4 months

Accessing Array Elements intExp1, intExp2 >= 0 indexExp1 = row position indexExp2 = column position

Accessing Array Elements (continued)

Two-Dimensional Arrays and the Instance Variable length 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 (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].length is 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

Two-Dimensional Arrays: Special Cases: Different Number of columns in each row int[][] board = new int[5][] Create columns Such arrays are known as “ragged” arrays

Two-Dimensional Array Initialization During Declaration

Two-Dimensional Array Initialization During Declaration (continued) 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 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; Print for (row = 0; row < matrix.length; row++) { for (col = 0; col < matrix[row].length; col++) System.out.printf("%7d", matrix[row][col]); System.out.println(); }

Two-Dimensional Arrays: Processing (continued) Input for (int row = 0; row < matrix.length; row++) { for (int col = 0; col < matrix[row].length; col++) matrix[row][col] = console.nextInt(); } Sum by Row for (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); }

Two-Dimensional Arrays: Processing (continued) 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);

Two-Dimensional Arrays: Processing (continued) 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;