Arrays - Personal Home Pages (at UEL)

Learning objectives
Arrays
By the end of this lecture you should be able to:
• create arrays of primitive types;
• use loops to process arrays;
• use an enhanced for loop to process an array;
• use arrays as method inputs and outputs;
• develop routines for accessing and manipulating arrays.
ESSENTIAL READING: Charatan and Kans (Chapter 5)
Introduction
• SO FAR: variables created to hold a single item of data.
• NOW: How to create and handle a very large number of data items?
• MAYBE: declare as many variables as you need?
public class TemperatureReadings
{
}
public static void main(String[] args)
{
}
// declare 7 variables to hold readings
double temperature1, temperature2, temperature3, temperature4,
temperature5, temperature6, temperature7;
// more code will go here
How to enter 7 temperature readings?
• Try using a for loop?
for (int i=1; i

• Ideally each variable should have the same name.
• This is exactly what an array allows us to do.
What is an array?
• An array is a data type that stores a collection of items.
• These items are sometimes referred to as the elements of the array.
• All the elements stored in a particular array must be of the same type but there is no
restriction on which type this is.
For example
o arrays can be used to hold a collection of int values;
o or a collection of char values;
o BUT they cannot be used to hold a mixture of int and char values.
Creating an array
• Array creation is a two-stage process:
1. declare an array variable;
2. allocate memory to store the array elements.
Declaring an array variable
Example: an array to hold a collection of integer variables:
int[] someArray;
• So, to declare an array temperature containing double values:
double[] temperature;
Allocating memory to store the array elements
• Need to state
o the size of the array ;
o the type of each individual array element .
• The array type and size are then put together with a special new operator.
Example: an array of 10 integers:
arrayName = new int[10];
23

Returning to the temperature array
• The temperature array holds seven double values:
temperature = new double[7];
• The two stages of array creation can be combined into one step as follows:
double[ ] temperature = new double[7];
The effect on computer memory of declaring an array
Computer Memory
temperature
item of type 'double'
item of type 'double'
item of type 'double'
item of type 'double'
item of type 'double'
item of type 'double'
item of type 'double'
24
Java Instructions
temperature = new double[7];

Naming the array elements
• Each element in an array shares the same name as the array.
• The individual elements are then uniquely identified by an additional index value.
• So the first element in the temperature array is temperature[0], the second
temperature[1] and so on:
0 1 2 3 4 5 6
Initializing an array
• An example:
double[] temperature = {9, 11.5, 11, 8.5, 7, 9, 8.5} ;
• This is the only instance in which all the elements of an array can be assigned explicitly
by listing out the elements in a single assignment statement.
• Once an array has been created, elements must be accessed individually.
Accessing array elements
• Array can be used like any other variable of the given type in Java.
• The assignment operator can be used to enter a value.
• You must specify which element to place the value in.
For example
• Allowing the user of the program to enter the value of the first temperature:
temperature[0] = sc.nextDouble();
25
temperature

More examples of accessing array elements
• Printing out the value of the sixth array element:
System.out.println(temperature[5]); // index 5 is the sixth element!
• Doubling the value of the fifth temperature.
temperature[4] = temperature[4] * 2;
• Checking if the temperature for the third day was a hot temperature:
if (temperature[2] >= 18)
{
}
System.out.println("it was hot today");
Using a variable as the array index
• The array index does not need to be a literal number such as 5 or 2; it can be any
expression that evaluates to an integer.
• More often than not an integer variable is used to access an array element.
Example:
• Assume that i is some integer variable:
System.out.println(temperature[i]); // index is a variable
• If the value of i is 4 then this will display temperature[4], if the value of i is 6
then this will display temperature[6], and so on.
26

Using a loop counter as an array index
Example
• Entering all seven temperature readings:
for(int i = 0; i

}
}
}
System.out.println("enter max temperature for day " + (i+1));
temperature[i] = sc.nextDouble();
// display temperatures
System.out.println(); // blank line
System.out.println("***TEMPERATURES ENTERED***");
for (int i = 0; i < temperature.length; i++)
{
}
Passing arrays as parameters
System.out.println("day "+(i+1)+" "+ temperature[i]);
• Program 5.1 contains all the processing within the main method.
• Now we will create two helper methods, enterTemps and displayTemps, to enter
and display temperatures respectively.
Program 5.2
import java.util.*;
public class TemperatureReadings2
{
public static void main(String[] args)
{
}
double[ ] temperature = new double[7];
enterTemps(temperature); // call helper method
displayTemps(temperature); // call helper method
// helper method to enter temperatures
private static void enterTemps(double[] temperatureIn)
{
}
Scanner sc = new Scanner(System.in);
for (int i = 0; i < temperatureIn.length; i++)
{
}
System.out.println("enter max temperature for day " + (i+1));
temperatureIn[i] = sc.nextDouble();
28

}
// helper method to display temperatures
private static void displayTemps(double[] temperatureIn)
{
}
System.out.println();
System.out.println("***TEMPERATURES ENTERED***");
for (int i = 0; i < temperatureIn.length; i++)
{
}
System.out.println("day "+(i+1)+" "+ temperatureIn[i]);
The effect on computer memory of passing an array as a parameter
• In the case of arrays, the value sent as a parameter is not a copy of each array element
but, instead, a copy of the array reference.
temperature
Computer Memory
temperatureIn
item of type double
item of type double
item of type double
item of type double
item of type double
item of type double
item of type double
29
Java Instructions
main(String[] args)
{
}
// call method with local array
enterTemps(temperature);
// method receives array reference
enterTemps(double[] temperatureIn)
{
}
// code here using temperatureIn

Returning an array from a method
• Reconsider the enterTemps method from program 5.2.
• Since this method fills the original array sent in as a parameter, it does not need to
return a value – its return type is therefore void.
• An alternative approach would be not to send an array to this method but, instead, to
create an array within this method and fill this array with values.
• This array can then be returned from the method:
// this method receives no parameter but returns an array of doubles
private static double[] enterTemps()
{
}
Scanner sc = new Scanner(System.in);
// create an array within this method
double[ ] temperatureOut = new double[7];
// fill up the array created in this method
for (int i = 0; i < temperatureOut.length; i++)
{
}
System.out.println("enter max temperature for day " + (i+1));
temperatureOut[i] = sc.nextDouble();
// send back the array created in this method
return temperatureOut;
Now we need to modify the main method
• The enterTemps method now returns an array.
• We need to modify the main method so that the returned array value is used to set the
value of the original temperature array :
// just declare the ‘temperature’ array but do not allocate it memory yet
double[ ] temperature;
// ‘temperature’ array is now set to the return value of ‘enterTemps’
temperature = enterTemps();
• We have not sized the temperature array once it has been declared.
• Instead the temperature array will be set to the size of the array returned by
enterTemps, and it will contain all the values of the array returned by
enterTemps.
30

The enhanced 'for' loop
• Java 5 provides an enhanced version of the for loop to simplify array processing.
• This loop requires no counter.
Example
• To display on the screen each value from the temperature array:
/* the enhanced for loop iterates through elements of an array without the
need for an array index */
for (double item : temperature) // variable holds consecutive array elenents
{
}
System.out.println(item);
• The loop header is to be read ad “for each item in the temperature array”.
When to use the enhanced 'for' loop
• You should use an enhanced for loop only when
o you wish to access the entire array (and not just part of the array);
o you wish to read the elements in the array, not modify them;
o you do not require the array index for additional processing.
Some useful array methods
• We will develop some methods for processing an array.
• We will use a simple integer array for this example.
• Here is the outline of the program we are going to write in order to do this :
import java.util.*;
public class SomeUsefulArrayMethods
{
public static void main (String[] args)
{
Scanner sc = new Scanner(System.in);
int[] someArray; // declare an integer array
// ask user to determine size of array
System.out.println("How many elements to store?");
int size = sc.nextInt();
// size array now
31

}
}
someArray = new int[size];
// call methods here
// methods to process an array here
Array maximum: design
• Method to find the maximum value in an array:
SET result TO first value in array
LOOP FROM second element in array TO last element in array
BEGIN
IF current element > result
BEGIN
SET result TO current element
END
END
RETURN result
Array maximum: implementation
private static int max (int[] arrayIn)
{
}
int result = arrayIn[0]; // set result to the first value in the array
// this loops runs from the 2nd item to the last item in the array
for (int i=1; i < arrayIn.length; i++)
{
}
{
}
if (arrayIn[i] > result)
return result;
result = arrayIn[i]; // reset result to new maximum
32

Array maximum: an alternative implementation
// this version of ‘max’ makes use of an enhanced ‘for’ loop
private static int max (int[] arrayIn)
{
}
int result = arrayIn[0]; // set result to the first value in the array
// this loops runs through all items in the array
for (int currentElement: arrayIn)
{
}
{
}
if (currentElement > result)
return result;
Array summation: design
result = currentElement; // reset result to new maximum
• Method that calculates the total of all the values in the array:
SET total TO zero
LOOP FROM first element in array TO last element in array
BEGIN
SET total TO total + value of current element
END
RETURN total
Array summation: implementation
private static int sum (int[] arrayIn)
{
}
int total = 0;
for (int currentElement : arrayIn)
{
}
total = total + currentElement;
return total;
33

Array membership: design
• A method to determine whether or not an array contains a particular value:
LOOP FROM first element in array TO last element in array
BEGIN
IF current element = item to find
BEGIN
EXIT loop and RETURN true
END
END
RETURN false
Array membership: implementation
private static boolean contains (int[] arrayIn, int valueIn)
{
}
// enhanced ‘for’ loop used here
for (int currentElement : arrayIn)
{
}
if (currentElement == valueIn)
{
}
return true; // exit loop early if value found
return false; // value not present
Array search: design
• A method to determine the position of an item within the list:
LOOP FROM first element in array TO last element in array
BEGIN
IF current element = item to find
BEGIN
EXIT loop and RETURN current index
END
END
RETURN -999
34

Array search: implementation
private static int search (int[] arrayIn, int valueIn)
{
}
// enhanced ‘for’ loop should not be used here!
for (int i=0; i < arrayIn.length; i++)
{
}
if (arrayIn[i] == valueIn)
{
}
return i; // exit loop with array index
return -999; // indicates value not in list
35

Programming exercise
1. Consider a room booking program that keeps track of the capacity of 5 rooms in a
building.
a) Declare and initialise an array, rooms, to hold the following capacities:
Room 1: capacity 30
Room 2: capacity 25
Room 3: capacity 50
Room 4: capacity 30
Room 5: capacity 40
b) Write a method, displayRooms, that accepts the array of room capacities
and displays the capacity of each room.
c) Add an instruction in main to call the displayRooms method.
Advanced:
d) Write a method, checkAllRooms, which accepts the array of rooms and a
required capacity and displays all rooms that meet that capacity.
e) Add an instruction in main to call the checkAllRooms method.
f) Write a method, changeCapacity, which accepts the array of rooms, a
room number and a new capacity for this room and updates the capacity of
the given room.
g) Add instructions in main to call the checkCapacity method and then the
displayRooms method to check to check that the given capacity has been
changed.
h) We-write this program so that it us menu driven and add any other options
you wish (such as checking the capacity of a single room).
36