presentation slides for

JAVA, JAVA, JAVA

Object-Oriented Problem Solving
Third Edition
Ralph Morelli | Ralph Walde
Trinity College
Hartford, CT

published by Prentice
Hall
 Java, Java, Java
Object Oriented Problem Solving

Chapter 9: Arrays and Array

Processing
 Objectives
• Know how to use array data structures.
• Be able to solve problems that require
collections of data.
• Know how to sort an array of data.
• Be familiar with sequential and binary
search algorithms.
• Have a better understanding of inheritance
and polymorphism.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Outline
• Introduction
• One-Dimensional Arrays
• Simple Array Examples
• Example: Counting Frequencies of Letters
• Array Algorithms: Sorting
• Array Algorithms: Searching
• Two-Dimensional and Multidimensional Arrays
• Object-Oriented Design: Polymorphic Sorting
• From the Java Library: Vector
• Case Study: A N-Player Computer Game
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Introduction
• An array is a named collection of
contiguous storage locations holding data of
the same type.
• Arrays elements: referenced by position
within a structure rather than by name.
• Example: 26 buttons ‘A’ to ‘Z’.
Without Arrays With Arrays
JButton button1 = new JButton(“A”); JButton letter[] = new JButton[26];
JButton button2 = new JButton(“B”); for (int k = 0; k < 26; k++)
JButton button3 = new JButton(“C”); letter[k] = new JButton(“A” + k);
JButton button4 = new JButton(“D”);
JButton button5 = new JButton(“E”);
JButton button6 = new JButton(“F”); The kth JButton
…
JButton button26 = new JButton(“Z”);
in an array.

Reference by name
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 One-Dimensional Arrays
• An array element is referred to its position within
the array.
• For an n-element array named arr, the elements are
named arr[0], arr[1], arr[2], ...,arr[n-1].
• The following array contains 15 int elements.
Arrays are zero
indexed.

• Array syntax : arrayname [ subscript ]

where arrayname is the array name and subscript is
an integer giving the element’s relative position.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Referring to Array Elements

• Valid References: Suppose j is 5 and k is 7.

arr[4] // Refers to 16
arr[j] // Is arr[5] which refers to 20
arr[j + k] // Is arr[5+7] which is arr[12] which refers to 45
arr[k % j] // Is arr[7%5] which is arr[2] which refers to -1

• Invalid References:
arr[5.0] // 5.0 is a float and can't be an array subscript
arr['5'] // '5' is a character not an integer
arr["5"] // "5" is a string not an integer
arr[-1] // Arrays cannot have negative subscripts
arr[15] // The last element of arr has subscript 14
arr[j*k] // Since j*k equals 35

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Are Arrays Objects?
• Arrays are (mostly) treated as objects:
– Instantiated with the new operator.
– Have instance variables (e.g., length).
– Array variables are reference variables.
– As a parameter, a reference to the array is passed
rather than copies of the array’s elements.
• But…
– Arrays don’t fit into the Object hierarchy.
– Arrays don’t inherit properties from Object.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Some Array Terminology
• An empty array is contains zero variables.
• The variables are called components.
• The length of the array is the number of
components it has.
• Each component of an array has the same
component type.
• A one-dimensional array has components that are
called the array’s elements. Their type is the array’s
element type.
• An array’s elements may be of any type, including
primitive and reference types.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Declaring and Creating an Array
• Creating a one-dimensional array: Indicate both the
array’s element type and its length.
• Declare the array’s name and create the array itself.

int arr[]; // Declare a name for the array

arr = new int[15]; // Create the array itself

• Combine two steps into one:

int arr[] = new int[15];

The array’s The array contains 15

name is arr. int variables.

• 15 variables: arr[0], arr[1], .., arr[14] (zero indexed)

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
Creating an Array of Strings

Declare array variable.

Instantiate the array.

Store 5 Strings in it.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Creating an Array of Students
Student school[] = new Student[3]; // Create an array of 3 Students
school[0] = new Student("Socrates"); // Create the first Student
school[1] = new Student("Plato"); // Create the second Student
school[2] = new Student("Aristotle"); // Create the third Student

• Debugging Tip:
Creating a new array
does not also create the
objects that are stored in
the array. They must be
instantiated separately.
There are four objects
here. One array and 3
Students.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Creating an Array of Students
Student student1 = new Student (“Socrates”);
Student student2 = new Student (“Plato”);
Student student3 = new Student (“Aristotle”);
Student school[] = new Student [3];
school[0] = student1;
school[1] = student2;
school[2] = student3;

The array stores

references to objects,
not the objects
themselves.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Initializing Arrays
• Array elements are initialized to default values:
– Integer and real types are initialized to 0.
– Reference types (objects) are initialized to null.
• Arrays can be assigned initial values when they are
created:

int arr[] = { -2,8,-1,-3,16,20,25,16,16,8,18,19,45,21,-2 } ;

String strings[] = { "hello", "world", "goodbye", "love" } ;

• Java Language Rule: When an array initialization

expression is used, don’t use the keyword new to create
the array.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Assigning and Using Array Values
• Subscripted array variables are used like other variables:
arr[0] = 5;
arr[5] = 10;
arr[2] = 3;
strings[0] = "who";
strings[1] = "what";
strings[2] = strings[3] = "where";

• A loop to assign the first 15 squares, 1, 4, 9 …, to the

array arr: for (int k = 0; k < arr.length; k++)
arr[k] = (k+1) * (k+1);

• A loop to print the values of arr: Note: length is

for (int k = 0; k < arr.length; k++)
an instance
System.out.println(arr[k]); variable, not a
method.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Example: Print an Array
• Print an array of int and an array of double:
public class PrintArrays { These
static final int ARRSIZE = 10; // The array's size
must be
static int intArr[] = new int[ARRSIZE]; // Create the int array
static double realArr[] = { 1.1, 2.2, 3.3, 4.4, static ...
5.5, 6.6, 7.7, 8.8, 9.9, 10.10 }; // And a double array

public static void main(String args[]) {

System.out.println("Ints \t Reals");
Program Output
for (int k = 0; k < intArr.length; k++)
Ints Reals
System.out.println( intArr[k] + " \t " + realArr[k]); 0 1.1
} // main() 0 2.2
} // PrintArrays 0 3.3
0 4.4
0 5.5
0 6.6

… in order to refer Uninitialized int

0
0
7.7
8.8

to them in static array has default

0
0
9.9
10.1

main() values of 0.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Example: Store the First 100 Squares
public class Squares {
static final int ARRSIZE = 100; // The array's size
static int intArr[] = new int[ARRSIZE]; // Create an int array

public static void main(String args[]) {

for (int k = 0; k < intArr.length; k++) // Initialize the array
intArr[k] = (k+1) * (k+1);

System.out.print("The first 100 squares are"); // Print a heading

for (int k = 0; k < intArr.length; k++)
{ // Print the array
if (k % 10 == 0)
System.out.println(" "); // 10 elements per row
System.out.print( intArr[k] + " ");
} // for
Program Output
} // main() The first 100 squares are
} // Squares 1 4 9 16 25 36 49 64 81 100
121 144 169 196 225 256 289 324 361 400
441 484 529 576 625 676 729 784 841 900
961 1024 1089 1156 1225 1296 1369 1444 1521 1600
1681 1764 1849 1936 2025 2116 2209 2304 2401 2500

2601 2704 2809 2916 3025 3136 3249 3364 3481 3600

3721 3844 3969 4096 4225 4356 4489 4624 4761 4900

5041 5184 5329 5476 5625 5776 5929 6084 6241 6400

6561 6724 6889 7056 7225 7396 7569 7744 7921 8100
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
8281 8464 8649 8836 9025 9216 9409 9604 9801
 Generating Random Numbers
• A random number generator generates numbers
that can be used to simulate a coin toss or die roll.
• The numbers generated are pseudorandom.
• Math.random() generates a double value in the
range [0.0, 1.0) -- that is, 0.0 to 0.999999999.
• Using Math.random() to simulate a coin flip:
int coinFlip = (int)(Math.random() * 2); // Heads or tails

• (Math.random() * 2) gives some value in the range 0.0 to

1.999999. When this value is converted to an int by (int),
it gives either 0 or 1, corresponding to heads or tails.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Generating Random Numbers (cont)
• An expression of the form
(int)(Math.random() * N)
will generate random integer values in the
range 0 to N-1.
• N is called the scaling factor.
• To generate values in the range 0 to 5, use:
(int)(Math.random() * 6);
• To simulate a die roll we must shift the
values into the range 1 to 6:
int die = 1 + (int)(Math.random()
* 6);
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
Example: Counting Letter Frequencies
• Design a class that can be used to store the
frequencies of letters of the alphabet.
public class LetterFreq {
private char letter; //A character being counted
private int freq; //The frequency of letter

public LetterFreq(char ch, int fre) {

letter = ch;
freq = fre;
}
public char getLetter() {
return letter;
}
public int getFreq() {
return freq;
}
public void incrFreq() {
freq++;
}
} //LetterFreq

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 A Class to Count Frequencies
• A class that counts letters in a document.
public class AnalyzeFreq {
private LetterFreq[] freqArr; // An array of frequencies

public AnalyzeFreq() {
freqArr = new LetterFreq[26];
for (int k = 0; k < 26; k++) {
freqArr[k] = new LetterFreq((char)('A' + k), 0);
} //for
}
public void countLetters(String str) {
char let; //For use in the loop. Note how it uses an
str = str.toUpperCase();
for (int k = 0; k < str.length(); k++) { array of LetterFreq
let = str.charAt(k);
if ((let >= 'A') && (let <= 'Z')) { objects to store letters
freqArr[let - 'A'].incrFreq();
} // if and their frequencies.
} // for
} // countLetters()

public void printArray() {

for (int k = 0; k < 26; k++) {
System.out.print("letter: " + freqArr[k].getLetter());
System.out.println(" freq: " + freqArr[k].getFreq());
} //for
} // printArray()
} //AnalyzeFreq

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Sorting Arrays
• Sorting is the process of arranging an array’s
elements into increasing or decreasing order.
• The insertion sort algorithm views the array as
divided into two parts, the sorted and unsorted parts.
On each iteration, it moves one element from the
unsorted to its correct position in the sorted part.

Insertion Sort of an array, arr, of N elements into ascending order

1. For k assigned 1 through N-1
2. Remove the element arr[k] and store it in x.
3. For i starting at k-1 and for all preceding elements greater than x
4. Move arr[i] one position to the right in the array.
5. Insert x at its correct location.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Method Design: insertionSort()
• Array parameters are references. Changes made
to the array in the method will persist.
/**
* Goal: Sort the values in arr into ascending order
* Pre: arr is not null. Note how an array
* Post: The values arr[0]...arr[arr.length-1] will be
* arranged in ascending order.
parameter is specified.
*/
public void insertionSort(int arr[]) {
int temp; // Temporary variable for insertion
for (int k = 1; k < arr.length; k++) { // For each pass
temp = arr[k]; // Remove element from array
int i;
for (i = k-1; i >= 0 && arr[i] > temp; i--) // Move larger preceding
arr[i+1] = arr[i]; // elements right by one space
arr[i+1]= temp;
} // for Note how an array
} // insertionSort()
argument is passed.
int myArr[] = { 21, 13, 5, 10, 14 };
insertionSort(myArr);

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Passing an Array Parameter
• When an array is passed to a method, both the array reference
(anArr) and the parameter (arr) refer to the same object.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Pass by Value
• Pass by Value: When a value of primitive type is
passed to a method, a copy of the value is passed.
Any changes to the copy, have no effect on the
original value. public void add1(int n) {
System.out.println("n = " + n);
Num’s value is n = n + 1;
System.out.println("n = " + n);
copied to n }

• For the add1() method, any changes made to its

parameter n do not persist beyond the method.
int Num = 5; Num = 5
System.out.println("Num = " + Num); n = 5
add1(Num); outputs n = 6
System.out.println("Num = " + Num); Num = 5

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Pass by Reference
• Pass by Reference: When a reference to an object
(e.g., and array) is passed to a method, changes
made to the object do persist beyond the method.
• Suppose we have a Sort class containing the
insertionSort() method and a print() method.
int intArr[] = { 21, 20, 27, 24, 19 }; // Initialize
Sort sorter = new Sort();
sorter.print(intArr); // Print
sorter.insertionSort(intArr); // Sort
sorter.print(intArr); // Print again

Outputs

21 20 27 24 19
19 20 21 24 27

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Implementation: The Sort Class
public class Sort {
public void print(int arr[]) {
for (int k = 0; k < arr.length; k++) // For each integer
System.out.print( arr[k] + " \t "); // Print it
System.out.println();
} // print()

public static void main(String args[]) {

int intArr[] = { 21, 20, 27, 24, 19 };
Sort sorter = new Sort();
sorter.print(intArr);
sorter.bubbleSort(intArr);
sorter.print(intArr);
} // main()
} // Sort
public void insertionSort(int arr[]) {
int temp; // Temporary variable for insertion
for (int k = 1; k < arr.length; k++) { // For each pass
temp = arr[k]; // Remove element from array
int i;
for (i = k-1; i >= 0 && arr[i] > temp; i--) // Move larger preceding
arr[i+1] = arr[i]; // elements right by one
arr[i+1]= temp;
} // for
} // insertionSort()

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Selection Sort Algorithm
• Example: Sorting a deck of cards.
– Cards are arranged from 2 to Ace.
– Suits arranged clubs, diamonds, hearts, spades.
• Strategy: Lay the 52 cards face up in a row. Select
the smallest card (2 of clubs), and exchange it with
the card in the first location. Move the next smallest
to the second location, and so on.
1. For count assigned 1 to 51 // Outer loop
2. smallestCard = count
3. For currentCard assigned count+1 to 52 // Inner loop
4. If deck[currentCard] < deck[smallestCard]
5. smallestCard = currentCard
6. If smallestCard != count // You need to swap
7 Swap deck[count] and deck[smallestCard]

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Algorithm Design: Swapping Elements
• A temporary variable must be used when swapping
the values of two variables in memory.
• Suppose you have the array: 1 4 2 8
• Swapping 4 and 2 the wrong way:
arr[pair-1] = arr[pair];
arr[pair] = arr[pair-1];
results in: 1 2 2 8
• Swapping 4 and 2 the proper way:
temp = arr[pair-1]; // Save first element in temp
arr[pair-1] = arr[pair]; // Overwrite first with second
arr[pair] = temp; // Overwrite second with temp (i.e.,first)

results in: 1 2 4 8
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Design: The Search Class

Uses

Two different search()

strategies.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Array Algorithm: Sequential Search
• Problem: Search an array for a key value. If the
array is not sorted, we have to search sequentially.
/**
* Performs a sequential search of an integer array
* @param arr is the array of integers
* @param key is the element being searched for
* @return the key's index is returned if the key is
* found otherwise -1 is returned
* Pre: arr is not null
* Post: either -1 or the key's index is returned
*/ Return as
public int sequentialSearch(int arr[], int key) {
for (int k = 0; k < arr.length; k++)
soon as the
if (arr[k] == key) key is
return k;
return -1; // Failure
found.
} // sequentialSearch()
Search fails if you get
to the end of the array.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Array Algorithm: Binary Search
• Binary search uses a divide-and-conquer strategy
on a sorted array.
• Divide the array in half on each iteration, limiting
the search to that half which could contain the key.
• Example: Guessing a number between 1 and 10.
1 2 3 4 5 6 7 8 9 10

Too high Too low

First
guess
1 2 3 4 6 7 8 9 10

Second Second
guess guess

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 The binarySearch() Method
• Algorithm Design: low and high point to first and last
elements of the subarray, and mid gives its current
midpoint. If low becomes
/**
greater than
* Pre: arr is an array of int in ascending order
* Post: -1 or arr[k] where arr[k] == key
high, the key is
*/
public int binarySearch(int arr[], int key) {
not in the array.
int low = 0; // Initialize bounds
int high = arr.length - 1;
while (low <= high) { // While not done
int mid = (low + high) / 2;
if (arr[mid] == key)
Calculate a return mid; // Success
else if (arr[mid] < key)
new low = mid + 1; // Search top half
else
midpoint. high = mid - 1; // Search bottom half
} // while
return -1; // Post condition: low > high implies search failed
} // binarySearch()
Update low and
high to cut the
array in half.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 Two-Dimensional Arrays
• Two-dimensional array: an array whose components are
themselves arrays.
• Example: Compiling daily rainfall data. A one-dimensional
array makes it hard to calculate average monthly rainfall:

double rainfall[] = new double[365];

• A two-dimensional array is an array of arrays. The

first is the 12 months, indexed from 0 to 11. Each
month array is an array of 31 days, indexed from 0
to 30.
double rainfall[][] = new double[12][31];

Month index Day index

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 A More Appropriate 2-D Representation
• What is rainfall[0][4] ? Avoid zero indexing by creating an
extra row and column and ignoring the 0 indexes.
double rainfall[][] = new double[13][32];

Don’t use the 0

indexes.

January 5 is
now at
rainfall[1][5]

rainfall[1][5] = 1.15; // Rainfall for January 5

System.out.println(rainfall[4][1]); // April 1st
rainfall[13][32] = 0.15 ; // No such element
rainfall[11][32] = 1.3; // No such column
rainfall[13][30] = 0.74; // No such row

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Initializing a Two-Dimensional Array
• We can use unit indexed loops to initialize the two-
dimensional rainfall array:
/**
* Initializes a 2-D array
* @param rain is a 2D-array of rainfalls A 2-D array
* Pre: rain is non null
* Post: rain[x][y] == 0 for all x,y in the array parameter
* Note that the loops use unit indexing.
*/
public void initRain(double rain[][]) {
for (int month = 1; month < rain.length; month++)
for (int day = 1; day < rain[month].length; day++)
rain[month][day] = 0.0;
} // initRain() Nested for loops
iterate 12 x 31 times

• Method call: pass the name of the 2-D array to the method:
initRain(rainfall); // Sample method call

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Example: Rainfall Data

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Calculate Average Daily Rainfall

/**
* Computes average daily rainfall
* @param rain is a 2D-array of rainfalls
A 2-D array
* @return The sum of rain[x][y] / 356 parameter
* Pre: rain is non null
* Post: The sum of rain / 365 is calculated
* Note that the loops are unit indexed
*/ Nested for loops
public double avgDailyRain(double rain[][]) { iterate 12 x 31 times
double total = 0;
for (int month = 1; month < rain.length; month++)
for (int day = 1; day < rain[month].length; day++)
total += rain[month][day];
return total/365;
} // avgDailyRain() Method call uses the
array’s name.
System.out.println("Daily Avg: " + avgRainForMonth(rainfall));

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Calculate Average Rain for a Month
/**
* Computes average rainfall for a month
* @param rain is a 2D-array of rainfalls
* @param month is the month of the year, 1 ... 12
Just iterate
* @param nDays is the number of days in month, 1 ... 31 over the
* @return The sum of rain[month] / nDays month
* Pre: 1 <= month <= 12 and 1 <= nDays <= 31
* Post: The sum of rain[month] / nDays is calculated array.
*/
public double avgRainForMonth(double rain[][], int month, int nDays) {
double total = 0;
for (int day = 1; day < rain[month].length; day++)
total = total + rain[month][day];
return total/nDays;
} // avgRainForMonth() We have to tell it how
many days in the month.

System.out.println("March Avg: " + avgRainForMonth(rainfall, 3, 31));

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

Calculate Average Rain for a Month (cont)
• Pass just part of a 2-D array -- e.g., a month.
/**
* Computes average rainfall for a given month Pass the array for
* @param monthRain is a 1D-array of rainfalls the given month.
* @param nDays is the number of days in monthRain
* @return The sum of monthRain / nDays
* Pre: 1 <= nDays <= 31
* Post: The sum of monthRain / nDays is calculated
*/
public double avgRainForMonth(double monthRain[], int nDays) {
double total = 0;
for (int day = 1; day < monthRain.length; day++)
total = total + monthRain[day]; We’re passing
return total/nDays; a reference to
} // avgRainForMonth()
a 1-D array.

System.out.println("March Avg: " + avgRainForMonth(rainfall[3], 31));

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Array Arguments and Parameters
• The argument
in a method call
must match the
data type in the
method
definition. This
applies to all
parameters,
including array
parameters.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Multidimensional Arrays
• A 3-dimensional array can be used to record
rainfall over a ten year period.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 A 3-D Rainfall Array
• Declaring a 3-D Array:

final int NYEARS = 10;

final int NMONTHS = 13;
final int NDAYS = 32;
double rainfail[][][] = new double[NYEARS][NMONTHS][NDAYS];

• Initializing a 3-D Array:

for (int year = 0; year < rainfall.length; year++)

for (int month = 0; month < rainfall[year].length; month++)
for (int day = 0; day < rainfall[year][month].length; day++)
rainfall[year][month][day] = 0.0;

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Array Initializers
• For small arrays, an initializer expression
can be used to assign initial values:
A 2 x 3 array of int.

int a[][] = { {1, 2, 3}, {4, 5, 6} } ; A 2 x 2 array of char.

char c[][] = { {'a', 'b'}, {'c', 'd'} } ;
double d[][] = { {1.0, 2.0, 3.0}, {4.0, 5.0}, {6.0, 7.0, 8.0, 9.0} } ;

A 3-row array of doubles

where each row has a
different length.

• Each dimension of a multidimensional array

can have a different length.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 OOD: Polymorphic Sorting (Optional)

• Task: Write a
method that can sort
an array of any kind
of object.

Because the polymorphic

compareTo() method
imposes an order on its
objects, it can be used to
sort any kind of object.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 OOD: Polymorphic sort() Method

An array of
Comparables
// Polymorphic sort method
public static void sort(Comparable[] arr) {
Comparable temp; // Temporary variable for swap
for (int pass = 1; pass < arr.length; pass++) // For each pass
for (int pair = 1; pair < arr.length ; pair++ ) // For ea pair
if (arr[pair].compareTo(arr[pair-1]) < 0) { // Compare
temp = arr[pair-1]; // and swap
arr[pair-1] = arr[pair];
arr[pair] = temp;

} // sort()
} // if
The compareTo()
method is polymorphic.
It is implemented
differently for each
different type of Object.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
OOD: The Comparable Interface

public abstract interface Comparable {

public int compareTo(Object obj) ;

}

Return value Meaning

<0 this object < obj
0 this object == obj
>0 this object > obj

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 OOD: Example Sort
• Create and sort an array of Integer and an array
of Float, both of which implement Comparable.

public static void main(String args[]) {

Two different
Integer iArr[] = new Integer[20]; // The arrays to sort kinds of array.
Float fArr[] = new Float[20]; // The arrays to sort

for (int k = 0; k < anArr.length; k++) { // Initialize with random values

iArr[k] = new Integer((int)(Math.random() * 10000));
fArr[k] = new Float(Math.random() * 10000);
}

sort(iArr); // Sort and print the arrays

print(iArr);
sort(fArr);
print(fArr);

} // main()
Sorted by the same
method.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 From the Library: java.util.Vector
• The java.util.Vector class implements an array of
objects that can grow as needed (dynamic).
• Regular arrays are limited to their initial size. They
cannot grow or shrink. (static)

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Vector Illustration
• Use a Vector to store items when you don’t know in
advance how many items there are.
import java.util.Vector;

public class VectorDemo {

public static void printVector( Vector v) {

for (int k=0; k < v.size(); k++)
System.out.println(v.elementAt(k).toString());
} // printVector()
public static void main(String args[]) {
Vector vector = new Vector(); // An empty vector
int bound = (int)(Math.random() * 20);
for (int k = 0; k < bound; k++ ) // Insert a random
vector.addElement(new Integer(k)); // number of Integers
printVector(vector); // Print the elements
} // main()
} // VectorDemo

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Case Study: an N - Player Game
• We use array to store the players in an N-player
game.
• We use the following class hierarchy.

The
ComputerGame
class uses an
array of Player
objects.

A TwoPlayerGame is a special
case of ComputerGame now.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 The ComputerGame Class
• The ComputerGame class is abstract because its
gameOver() and getWinner() methods are
implemented in its subclasses.
Abstract class.

Note use of protected (#)

variables so they can be
inherited by subclasses.

Abstract methods.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 N-Player Word Guess Game
• In the Word Guess game from Chapter 8 players take turns
guessing a secret word.
• We need only minor changes to the WordGuess and WordGuesser
classes.
New
constructor.

Rewrite the
play()
method.

The new
WordGuesser is
a subclass of
Player.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays
 A GUI-Based Game (Optional)
• We expand the ComputerGame hierarchy to allow GUI-based
games.
• We design a GUIPlayableGame interface to handle the interaction
between the game and the user interface.

All games, command-line or GUI,

implement these methods.

GUI games implement the

submitUserMove() mehtod.

Note that Strings are used to pass

information back and forth
between the game and interface.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 The Sliding Tile Puzzle
• In the Sliding Tile Puzzle the goal is
to move tiles into the correct
locations.
• The SlidingTilePuzzle class uses a
char array to represent the puzzle
and String to represent the puzzle’s
solution.
• SlidingTilePuzzle.java
• Sliding Tile Demo: Applet version.

Inheritance: SlidingTilePuzzle
inherits ComputerGame and
GUIPlayableGame methods.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 The SlidingGUI Class
• The SlidingGUI class uses a
JButton array to represent the
puzzle’s tiles.
• Its actionPeformed() method
enforces the legal moves.
• SlidingGUI.java

Inheritance: SlidingGUI is a
JFrame that uses an array of
JButtons to represent the tiles.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Technical Terms
• array • multidimensional array
• array initializer • one-dimensional array
• array length • polymorphic sort
• binary search method
• data structure • selection sort
• element • sequential search
• element type • sorting
• insertion sort • subscript
• two-dimensional array

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Summary Of Important Points
• An array is a named collection of contiguous
storage locations holding data of the same type.
• An array’s values may be initialized by assigning
values to each array location. An initializer
expression may be included as part of the array
declaration.
• Insertion sort and selection sort are examples of
array sorting algorithms. Both algorithms require
making several passes over the array.

Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays

 Summary Of Important Points (cont)
• Array Parameters: When an array is passed as a
parameter, a reference to the array is passed rather
than the entire array itself.
• Swapping two elements of an array, or any two
locations in memory, requires the use of a
temporary variable.
• Sequential search and binary search are examples
of array searching algorithms. Binary search
requires that the array be sorted.
• For multidimensional arrays, each dimension of
the array has its own length variable.
Java, Java, Java, 3E by R. Morelli | R. Walde Copyright 2006. Chapter 9: Arrays