1. Java Programming: From Problem Analysis to Program Design, 3e Chapter 9
Arrays

2. 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

3. 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

4. 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

5. One-Dimensional Arrays

6. One-Dimensional Arrays (continued)

7. One-Dimensional Arrays (continued)
intExp = number of components in array >= 0
0 <= indexExp <= intExp

8. Array num: int[] num = new int[5];
Arrays
Array num: int[] num = new int[5];

9. Array List

10. Array List (continued)

11. Array List (continued)

12. Array List (continued)

13. Specifying Array Size During Program Execution

14. 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

15. 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

16. 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

17. 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

18. 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)

19. 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

20. 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] + " ");

21. 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;

22. Code to Initialize Array to Specific Value (10.00)
for (index = 0; index < arrSales.length;
index++)
arrSales[index] = 10.00;

23. Code to Read Data into Array
for (index = 0; index < arrSales.length;
index++)
arrSales[index] = console.nextDouble();

24. Code to Print Array for (index = 0; index < arrSales.length;
System.out.print(arrSales[index] + " ");

25. 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;

26. 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];

27. Determining Largest Element in Array (continued)

28. Determining Largest Element in Array (continued)

29. 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

30. The Assignment Operators and Arrays
Supposing I were to write: listB = listA; ?

31. The Assignment Operators and Arrays (continued)

32. The Assignment Operators and Arrays (continued)

33. 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

34. * 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))
...

35. * 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)

36. Methods for Array Processing

37. Methods for Array Processing (continued)

38. Methods for Array Processing (continued)

39. Methods for Array Processing (continued)

40. * 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();

41. 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";

42. Array of String Objects (continued)

43. * 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() ) { ...

44. 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.

45. Clock[] arrivalTimeEmp = new Clock[100];
Arrays of Objects (continued)
Clock[] arrivalTimeEmp = new Clock[100];

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

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

48. 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

49. Arrays and Variable Length Parameter List
We will skip this section for 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

50. Arrays and Variable Length Parameter List (continued)

51. Arrays and Variable Length Parameter List (continued)

52. 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

53. 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

54. * 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

55. 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); }

56. 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; }

57. 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); }

58. 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.)

59. 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!

60. 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

61. Two-Dimensional Arrays
inStock[0][1] holds inStock[4][2] holds 12

62. Two-Dimensional Arrays (continued)

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

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

65. Accessing Array Elements (continued)

66. 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

67. 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

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

69. 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

70. Two-Dimensional Array Initialization During Declaration

71. 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

72. Two-Dimensional Arrays: Special Cases: Initialization During Declaration

73. 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.

74. 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(); }

75. 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); }

76. 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); }

77. 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);

78. 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); }

79. 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

80. 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;