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

1
Java Programming From Problem Analysis to
Program Design, 3eChapter 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 gt 0
• 0 lt indexExp lt intExp

8
Array numint num new int5
Arrays
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, sales0 12.25, sales1 32.50, sales2
  16.90, sales3 23.00, and sales4 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 int10
• 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
• numList0 5
• numList1 10
• numList2 15
• numList3 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 weve dealt only with arrays that
  we assume are filled with valid data. However
  its 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 i0
  until i lt array.length.
• Instead we will loop from i0 until
• i lt variable_keeping_track_of_array

20
Processing One-Dimensional Arrays

• Loops used to step through elements in array and
  perform operations
• int list new int100
• int i
• for (i 0 i lt list.length i)
• //process listi, the (i 1)th
• //element of list
• for (i 0 i lt list.length i)
• listi console.nextInt()
• for (i 0 i lt list.length i)
• System.out.print(listi " ")

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 double10 int
index double largestSale, sum, average
22
Code to Initialize Array to Specific Value (10.00)
for (index 0 index lt arrSales.length
index) arrSalesindex 10.00
23
Code to Read Data into Array
for (index 0 index lt arrSales.length
index) arrSalesindex
console.nextDouble()
24
Code to Print Array
for (index 0 index lt arrSales.length
index) System.out.print(arrSalesinde
x " ")
25
Code to Find Sum and Average of Array
sum 0 for (index 0 index lt arrSales.length
index) sum sum
arrSalesindex if (arrSales.length ! 0)
average sum / arrSales.length else average
0.0
26
Determining Largest Element in Array
maxIndex 0 for (index 1 index lt
arrSales.length index) if
(arrSalesmaxIndex lt arrSalesindex)
maxIndex index //Note no need for braces
here largestSale arrSalesmaxIndex
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 lt index lt arraySize 1
• If index lt 0 or index gt 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 lt firstArray.length
index) if
(firstArrayindex ! secondArrayindex)
return false return true if
(isEqualArrays(listA, listB)) ...
35
Arrays as Parameters to Methods
//Why the extra parameter to this method?
In this second method, we dont 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
  StudentRecord20
• Can fill records with instances of StudentRecord
  objects as follows
• for(int j0 j ltrecords.length j)
• recordsj new StudentRecord()

41
Array of String Objects

• String nameList new String5
• nameList0 "Amanda Green"
• nameList1 "Vijay Arora"
• nameList2 "Sheila Mann"
• nameList3 "Rohit Sharma"
• nameList4 "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
  nameList0 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 ( nameList0.equals(Robert) ) ...
• How might you check to see if the first two
  elements of the array are identical?
• if ( nameList0.equals( nameList1 ) ) ...
• How might you check the length of the last
  element of the array?
• if ( nameListnamelist.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 Clock100
Arrays of Objects (continued)
46
Instantiating Array Objects
for (int j 0 j lt arrivalTimeEmp.length j)
arrivalTimeEmpj new Clock()
47
Instantiating Array Objects (continued)
arrivalTimeEmp49.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 i0
iltarrivalTimeEmp.length i) System.out.print(
arrivalTimeEmpi ) 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 212. This is for
your interest only at this point. Skip to the
slide on the foreach loop

• 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 (gt 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 list0
• In the next iteration, the value of num is
  list1, and so on
• for (double num numList)
• if (max lt 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
int56 // Create a 2-D array of 5 rows, with
6 cells per row // NOTE First index ROW,
second COLUMN
61
Two-Dimensional Arrays
inStock01 holds 7 inStock42 holds 12
62
Two-Dimensional Arrays (continued)
63
double sales new double105//e.g. keep
track of 10 employees over 4 months
Two-Dimensional Arrays (continued)
64
Accessing Array Elements

• intExp1, intExp2 gt 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 matrix0.length

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

• Each row of matrix is a one-dimensional array
  matrix0, in fact, refers to the first row
• The value of the expression
• matrix0.length
• is 15, the number of columns in the first row
• matrix1.length gives the number of columns in
  the second row, which in this case is 15, and so
  on

68
Two-Dimensional (Ragged) ArraysDifferent
Number of columns in each row
69
Two-Dimensional Arrays Special CasesDifferent
Number of columns in each row
int board new int5

• 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
CasesInitialization 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 lt
matrix.length row) for (col 0 col lt
matrixrow.length col)
matrixrowcol 10
Print for (row 0 row lt matrix.length
row) for (col 0 col lt
matrixrow.length col)
System.out.printf("7d", matrixrowcol)
System.out.println()
75
Two-Dimensional Arrays Processing (continued)
Input for (int row 0 row lt matrix.length
row) for (int col 0 col lt
matrixrow.length col) matrixrowcol
console.nextInt()
Sum by Rowfor (row 0 row lt matrix.length
row) sum 0 for (col 0 col lt
matrixrow.length col) sum sum
matrixrowcol System.out.println(
"Sum of row " (row 1)
" " sum)
76
Two-Dimensional Arrays Processing (continued)
Sum by Column for (col 0 col lt
matrix0.length col) sum 0 for
(row 0 row lt matrix.length row)
sum sum matrixrowcol
System.out.println("Sum of column " (col 1)
" " sum)
77
Two-Dimensional Arrays Processing (continued)
Largest Element in Each Row for (row 0 row lt
matrix.length row) largest
matrixrow0 for (col 1 col lt
matrixrow.length col) if
(largest lt matrixrowcol) largest
matrixrowcol 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
lt matrix0.length col) largest
matrix0col for (row 1 row lt
matrix.length row) if (largest lt
matrixrowcol) largest
matrixrowcol 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
• dataTypeintExp1intExp2intExpn
• Syntax to access component
• arrayNameindexExp1indexExp2indexExpn
• intExp1, intExp2, ..., intExpn positive
  integers
• indexExp1,indexExp2, ..., indexExpn
  non-negative integers

80
Loops to Process Multidimensional Arrays
double carDealers new double1057
for (i 0 i lt 10 i) for (j 0 j lt 5
j) for (k 0 k lt 7 k)
carDealersijk 10.00