EKT472: Object Oriented

Programming
Arrays
Motivation

How to organize 100 Student

objects?
100 different Student object names?
Organize data for efficient access
Class: different data types in one object
Array: multiple objects of the same type
 Overview
 An array
a single name for a collection of data values
all of the same data type
subscript notation to identify one of the values
 A carryover from earlier programming languages
 More than a primitive type, less than an object
like objects when used as method parameters
and return types
do not have or use inheritance
 Accessing each of the values in an array
 Usually a for loop
 Creating Arrays

 General syntax for declaring an array:

Base_Type[] Array_Name = new Base_Type[Length];

 Examples:
80-element array with base type char:
char[] symbol = new char[80];

100-element array of doubles:

double[] reading = new double[100];

70-element array of Species:

Species[] specimen = new Species[70];
 Three Ways to Use [ ] (Brackets)
with an Array Name
1. Declaring an array: int[] pressure
• creates a name of type "int array"
 types int and int[] are different
 int[]: type of the array
 int : type of the individual values

2. To create a new array, e.g. pressure = new int[100];

3. To refer to a specific element in the array

- also called an indexed variable, e.g.

pressure[3] = [Link]();
[Link]("You entered" + pressure[3]);
Some Array Terminology
Array name
temperature[n + 2]Index - also called a subscript
- must be an int,
- or an expression that evaluates to an int

temperature[n + 2]
Indexed variable - also called an
element or subscripted variable

Value of the indexed variable

temperature[n + 2] - also called an element of the array

temperature[n + 2] = 32;
Note that "element" may refer to either a single indexed
variable in the array or the value of a single indexed variable.
 Array Length
 Specified by the number in brackets when created with
new
 maximum number of elements the array can hold
 storage is allocated whether or not the elements are
assigned values

 the attribute length,

Species[] entry = new Species[20];
[Link]([Link]);

 The length attribute is established in the declaration and

cannot be changed unless the array is redeclared
 Subscript Range
 Array subscripts use zero-numbering
 the first element has subscript 0
 the second element has subscript 1
 etc. - the nth element has subscript n-1
 the last element has subscript length-1
 For example: an int array with 4 elements

Subscript: 0 1 2 3
Value: 97 86 92 71
 Subscript out of Range Error

 Using a subscript larger than length-1 causes a

run time (not a compiler) error
an ArrayOutOfBoundsException is thrown
 you do not need to catch it
 you need to fix the problem and recompile your code

 Other programming languages, e.g. C and C++,

do not even cause a run time error!
one of the most dangerous characteristics of
these languages is that they allow out of
bounds array indices.
Array Length Specified at Run-time

// array length specified at compile-time

int[] array1 = new int[10];

// array length specified at run-time

// calculate size…
int size = …;
int[] array2 = new int[size];
Programming Tip:
Use Singular Array Names

 Using singular rather than plural names for arrays

improves readability

 Although the array contains many elements the most

common use of the name will be with a subscript, which
references a single value.
 It is easier to read:
score[3] than
scores[3]
Initializing an Array's Values
in Its Declaration
 can be initialized by putting a comma-separated list in braces
 Uninitialized elements will be assigned some default value, e.g. 0 for
int arrays (explicit initialization is recommended)
 The length of an array is automatically determined when the values
are explicitly initialized in the declaration
 For example:
double[] reading = {5.1, 3.02, 9.65};
[Link]([Link]);

- displays 3, the length of the array reading

 Initializing Array Elements in a Loop
 A for loop is commonly used to initialize array elements
 For example:
int i;//loop counter/array index
int[] a = new int[10];
for(i = 0; i < [Link]; i++)
a[i] = 0;
 note that the loop counter/array index goes from 0 to length -
1
 it counts through length = 10 iterations/elements using the
zero-numbering of the array index

Programming Tip:
Do not count on default initial values for array elements
 explicitly initialize elements in the declaration or in a loop
 Arrays, Classes, and Methods
An array of a class can This excerpt from the Sales Report program
be declared and the in the text uses the SalesAssociate class
class's methods applied
to the elements of the to create an array of sales associates:
array.
public void getFigures()
create an array of {
SalesAssociates [Link]("Enter number of sales associates:");
numberOfAssociates = [Link]();
SalesAssociate[] record =
each array element is new SalesAssociate[numberOfAssociates];
a SalesAssociate for (int i = 0; i < numberOfAssociates; i++)
variable {
record[i] = new SalesAssociate();
[Link]("Enter data for associate " + (i + 1));
use the readInput record[i].readInput();
method of [Link]();
SalesAssociate }
}
Arrays and Array Elements
as Method Arguments
 Arrays and array elements can be
 used with classes and methods just like other objects
 be an argument in a method
 returned by methods
 public static void main(String[] arg)
{
Indexed Scanner keyboard = new Scanner([Link]);a
Variables [Link]("Enter your score on exam 1:");
int firstScore = [Link]();
as Method int[ ] nextScore = new int[3];
int i;
Arguments double possibleAverage;
for (i = 0; i < [Link]; i++)
nextScore[i] = 80 + 10*i;
nextScore is for (i = 0; i < [Link]; i++)
an array of ints {
possibleAverage = average(firstScore,
nextScore[i]);
[Link]("If your score on exam 2 is "
an element of
+ nextScore[i]);
nextScore is [Link]("your average will be "
an argument of + possibleAverage);
method }
average }
public static double average(int n1, int n2)
average {
return (n1 + n2)/2.0; Excerpt from ArgumentDemo
method definition } program in text.

Chapter 10 Java: an Introduction to Computer Science & Programming - Walter Savitch 16

Passing Array Elements

public static void main(String[] arg)

{
SalesAssociate[] record = new SalesAssociate[numberOfAssociates];
int i;
for (i = 0; i < numberOfAssociates; i++)
{
record[i] = new SalesAssociate();
[Link]("Enter data for associate " + (i + 1));
record[i].readInput();
}
m(record[0]);
}
public static void m(SalesAssociate sa)
{
}
 When Can a Method Change an
Indexed Variable Argument?
 primitive types are “call-by-value”
 only a copy of the value is passed as an argument
 method cannot change the value of the indexed
variable
 class types are reference types (“call by reference”)
 pass the address of the object
 the corresponding parameter in the method
definition becomes an alias of the object
 the method has access to the actual object
 so the method can change the value of the
indexed variable if it is a class (and not a primitive)
type
Passing Array Elements

int[] grade = new int[10];

[Link](grade[i]); // grade[i] cannot be changed

… method(int grade) // pass by value; a copy

{
}
______________________________________________________
Person[] roster = new Person[10];
[Link](roster[i]); // roster[i] can be changed

… method(Person p) // pass by reference; an alias

{
}
 Array Names as Method Arguments

 Use just the array name and no brackets

 Pass by reference
 the method has access to the original array and can
change the value of the elements
 The length of the array passed can be different
for each call
when you define the method you do not
need to know the length of the array that will
be passed
use the length attribute inside the method to
avoid ArrayIndexOutOfBoundsExceptions
 Example: An Array as an Argument
in a Method Call the method's argument
is the name of an array
of characters
public static void showArray(char[] a)
{
int i;
for(i = 0; i < [Link]; i++)
[Link](a[i]);
}
uses the length attribute
------------- to control the loop
char[] grades = new char[45]; allows different size arrays
[Link](grades); and avoids index-out-of-
bounds exceptions
 Arguments for the Method main
 The heading for the main method shows a parameter that is
an array of Strings:
public static void main(String[] arg)
 When you run a program from the command line, all words
after the class name will be passed to the main method in the
arg array.
java TestProgram Josephine Student
 The following main method in the class TestProgram will print
out the first two arguments it receives:
Public static void main(String[] arg)
{
[Link](“Hello “ + arg[0] + “ “ + arg[1]);
}

 In this example, the output from the command line above will
be:
Hello Josephine Student
Using = with Array Names:
Remember They Are Reference Types

int[] a = new int[3];

int[] b = new int[3];
for(int i=0; i < [Link]; i++) This does not create a
a[i] = i; copy of array a;
b = a; it makes b another name
[Link](a[2] + " " + b[2]); for array a.
a[2] = 10;
[Link](a[2] + " " + b[2]);

The output for this code will be:

A value changed in a
2 2
is the same value
10 10
obtained with b
 Using == with array names:
remember they are reference types
int i; a and b are both
int[] a = new int[3]; 3-element arrays of ints
int[] b = new int[3];
for(i=0; i < [Link]; i++) all elements of a and b are
a[i] = 0;
assigned the value 0
for(i=0; i < [Link]; i++)
tests if the
b[i] = 0; addresses of a
if(b == a) and b are equal,
[Link]("a equals b"); not if the array
else values are equal
[Link]("a does not equal b");

The output for this code will be " a does not equal b"
because the addresses of the arrays are not equal.
Behavior of Three Operations

Primitive Class Entire Array

Type Type Array Element
Assignment Copy content Copy Copy Depends on
(=) address address primitive/
class type
Equality Compare Compare Compare Depends on
(==) content address address primitive/
class type
Parameter Pass by Pass by Pass by Depends on
Passing value reference reference primitive/
(content) (address) (address) class type
Testing Two
Arrays for
public static boolean equals(int[] a,
int[] b)
{
Equality boolean match = false;
if ([Link] == [Link])
{
match = true; //tentatively
 To test two arrays int i = 0;
for equality you while (match && (i < [Link]))
{
need to define if (a[i] != b[i])
an equals i++;
match = false;

method that }
}
returns true if and return match;
only the arrays }

have the same

length and all
corresponding
values are equal
Methods public class returnArrayDemo
{
public static void main(String arg[])
that Return {
char[] c;

an Array c = vowels();
for(int i = 0; i < [Link]; i++)
[Link](c[i]);
}
public static char[] vowels()
 the address {
of the array is char[] newArray = new char[5];
newArray[0] = 'a';
passed newArray[1] = 'e';
 The local newArray[2] = 'i';
newArray[3] = 'o';
array name newArray[4] = 'u';
within the return newArray;
method is just }
}
c, newArray, and
another the return type of
name for the vowels are
original array
all the same type:
char []
 Partially Filled Arrays
 Sometimes only part of an array has been filled with data

 Array elements always contain something

 elements which have not been written to
 contain unknown (garbage) data so you should avoid
reading them

 There is no automatic mechanism to detect how many

elements have been filled
 you, the programmer need to keep track!

 An example: the instance variable countOfEntries (in the

class OneWayNoRepeatsList) is incremented every time
addItem is called (see the text)
Example of a Partially Filled Array

entry[0] Buy milk.

entry[1] Call home.
entry[2] Go to beach. countOfEntries - 1
entry[3]
garbage values
entry[4]

countOfEntries has a value of 3.

[Link] has a value of 5.
Multidimensional Arrays

 Arrays with more than one index

 number of dimensions = number of indexes

 Arrays with more than two dimensions are a simple extension of two-dimensional
(2-D) arrays

 A 2-D array corresponds to a table or grid

 one dimension is the row
 the other dimension is the column
 cell: an intersection of a row and column
 an array element corresponds to a cell in the table
 Table as a 2-Dimensional Array
 The table assumes a starting balance of $1000
 First dimension: row identifier - Year
 Second dimension: column identifier - percentage
 Cell contains balance for the year (row) and percentage
(column)
 Balance for year 4, rate 7.00% = $1311

Balances for Various Interest Rates

Compounded Annually
(Rounded to Whole Dollar Amounts)
Year 5.00% 5.50% 6.00% 6.50% 7.00% 7.50%
1 $1050 $1055 $1060 $1065 $1070 $1075
2 $1103 $1113 $1124 $1134 $1145 $1156
3 $1158 $1174 $1191 $1208 $1225 $1242
4 $1216 $1239 $1262 $1286 $1311 $1335
5 $1276 $1307 $1338 $1370 $1403 $1436
… … … … … … …
Chapter 11 Java: an Introduction to Computer Science & Programming - Walter Savitch 31
 Table as a 2-D Array Column Index 4
(5th column)

Indexes 0 1 2 3 4 5
0 $1050 $1055 $1060 $1065 $1070 $1075
1 $1103 $1113 $1124 $1134 $1145 $1156
2 $1158 $1174 $1191 $1208 $1225 $1242
3 $1216 $1239 $1262 $1286 $1311 $1335
Row Index 3 4 $1276 $1307 $1338 $1370 $1403 $1436
(4th row) … … … … … … …

 Generalizing to two indexes: [row][column]

 First dimension: row index
 Second dimension: column index
 Cell contains balance for the year/row and percentage/column
 All indexes use zero-numbering
 Balance[3][4] = cell in 4th row (year = 4) and 5th column
(7.50%)
 Balance[3][4] = $1311 (shown in yellow)

Chapter 11 Java: an Introduction to Computer Science & Programming - Walter Savitch 32

Java Code to Create a 2-D Array

Syntax for 2-D arrays is similar to 1-D arrays

Declare a 2-D array of ints named table

 the table should have ten rows and six columns
int[][] table = new int[10][6];
Method to Calculate the Cell Values
 balance(starting, years, rate) = (starting) x (1 +
rate)years
 The repeated multiplication by (1 + rate) can be
done in a for loop that repeats years times.
balance method in
class InterestTable
public static int balance(double startBalance, int years,
double rate)
{
double runningBalance = startBalance;
int count;
for (count = 1; count <= years; count++)
runningBalance = runningBalance*(1 + rate/100);
return (int) ([Link](runningBalance));
}
 Processing a 2-D Array:
for Loops Nested 2-Deep
 To process all elements of an n-D array nest n for loops
 each loop has its own counter that corresponds to an
index
 For example: calculate and enter balances in the interest
table
 inner loop repeats 6 times (six rates) for every outer loop
iteration
 the outer loop repeats 10 times (10 different values of
years)
int[][] table = new int[10][6]; Excerpt from
 so the inner repeats 10 x 6 = 60 times = # cells in table
int row, column; main method of
InterestTable
for (row = 0; row < 10; row++)
for (column = 0; column < 6; column++)
table[row][column] = balance(1000.00,
row + 1, (5 + 0.5*column));
 Multidimensional Array Parameters
and Returned Values
 Methods may have multi-D array parameters
 Methods may return a multi-D array as the value returned
 The situation is similar to 1-D arrays, but with more brackets
 Example: a 2-D int array as a method argument
public static void showTable(int[][] displayArray)
{ Notice how the number
int row, column; of rows is obtained
for (row = 0; row < [Link]; row++)
{
[Link]((row + 1) + " ");
for (column = 0; column < displayArray[row].length; column++)
[Link]("$" + displayArray[row][column] + " ");
[Link]();
Notice how the number showTable
}
of columns is obtained method from class
} InterestTable2
Implementation of
Multidimensional Arrays

 Multidimensional arrays are implemented as arrays of

arrays.
Example:
int[][] table = new int[3][4];
 table is a one-dimensional array of length 3
 Each element in table is an array with base type int.
 Access a row by only using only one subscript:
Note: [Link]
01table[0].length
2 3 gives the length (4) of the first row in
(which is 3 in this
0 the array case) is not the
1 same thing as
2 table[0] refers to the first
table[0].length
row in the array, which is a
one-dimensional array. (which is 4).
Ragged Arrays

 Ragged arrays have rows of unequal length

 each row has a different number of columns, or entries

 Ragged arrays are allowed in Java

 Example: create a 2-D int array named b with 5 elements in the first row, 7 in
the second row, and 4 in the third row:
int[][] b = new int[3][];
b[0] = new int[5];
b[1] = new int[7];
b[2] = new int[4];
Programming Example:
Employee Time Records

 The class TimeBook uses several arrays to keep track of employee

time records:
public class TimeBook
{
private int numberOfEmployees; hours[i][j] has
private int[][] hours; the hours for
private int[] weekHours; employee j on day i
private int[] dayHours;
. . .
}
weekHours[j] has
dayHours[i] has the
the week's hours for
total hours worked by all employee j+1
employees on day i
Nested Loops with Multidimensional Arrays
for (employeeNumber = 1;
employeeNumber <= numberOfEmployees; employeeNumber++)
{ // Process one employee
sum = 0;
for (dayNumber = 0; dayNumber < 5; dayNumber++)
sum = sum + hours[dayNumber][employeeNumber – 1];
weekHours[employeeNumber – 1] = sum;
}
0 1 2
0 8 0 9  The method computeWeekHours uses
1 8 0 9 nested for loops to compute the week's
total hours for each employee.
hours 2 8 8 8
array  Each time through the outer loop body,
3 8 8 4
the inner loop adds all the numbers in one
4 8 8 8 column of the hours array to get the value
0 1 2 for one element in the weekHours array.
weekHours
40 24 38
array
 Array of Objects
public class Student
{
private String _name;
private int _id;
private float _grade;

public Student() { _name = “none”; _id = 0; _grade = .0; }

public Student(String name, int id, float grade)
{ _name = name; _id = id; _grade = grade;}
}

public class Course

{
private String _name;
private Student[] _student;

public Course(String name, int numOfStudents)

{
_name = name;
_student = new Student[numOfStudents];
for (int i = 0; i < numOfStudents; i++)
_student[i] = new Student(); // how to init name,id,grade for each obj
}
}