Advanced Programming Lecture 6 Fall 2016

Copyright © 2014 by John Wiley & Sons. All rights reserved. 1
Chapter 7 – Arrays and Array Lists

Chapter Goals
 To collect elements using arrays and array lists
 To use the enhanced for loop for traversing arrays and array lists
 To learn common algorithms for processing arrays and array lists
 To work with two-dimensional arrays
 To understand the concept of regression testing

Arrays
 An array collects a sequence of values of the same type.
 Create an array that can hold ten values of type double:
new double[10]
• The number of elements is the length of the array
• The new operator constructs the array
 The type of an array variable is the type of the element to be stored, followed by [].

Arrays
 To declare an array variable of type double[]
double[] values;
 To initialize the array variable with the array:
double[] values = new double[10];
 By default, each number in the array is 0
 You can specify the initial values when you create the array
double[] moreValues =
{ 32, 54, 67.5, 29, 35, 80, 115, 44.5, 100, 65 };

Arrays
 To access a value in an array, specify which “slot” you want to
use
• use the [] operator
values[4] = 35;
 The “slot number” is called an index.
 Each slot contains an element.
 Individual elements are accessed by an integer index i, using
the notation array[i].
 An array element can be used like any variable.
System.out.println(values[4]);

Arrays
Figure 1 An Array of Size 10

Syntax 7.1 Arrays

Arrays
 The elements of arrays are numbered starting at 0.
 The following declaration creates an array of 10 elements:
 An index can be any integer ranging from 0 to 9.
 The first element is values[0]
 The last element is values[9]
 An array index must be at least zero and less than the size of
the array.
 Like a mailbox that is identified by a box number, an array
element is identified by an index.

Arrays – Bounds Error
 A bounds error occurs if you supply an invalid array index.
 Causes your program to terminate with a run-time error.
 Example:
values[10] = value; // Error
 values.length yields the length of the values array.
 There are no parentheses following length.

Declaring Arrays

Array References
 An array reference specifies the location of an array.
 Copying the reference yields a second reference to the same
array.

Array References
 When you copy an array variable into another, both variables refer to
the same array
int[] scores = { 10, 9, 7, 4, 5 };
int[] values = scores; // Copying array reference
 You can modify the array through either of the variables:
scores[3] = 10;
System.out.println(values[3]); // Prints 10
Figure 2 Two Array Variables Referencing the Same Array

Using Arrays with Methods
 Arrays can occur as method arguments and return values.
 An array as a method argument
public void addScores(int[] values)
{
for (int i = 0; i < values.length; i++)
{
totalScore = totalScore + values[i];
}
}
 To call this method
int[] scores = { 10, 9, 7, 10 };
fred.addScores(scores);
 A method with an array return value
public int[] getScores()

Partially Filled Arrays
 Array length = maximum number of elements in array.
 Usually, array is partially filled
 Define an array larger than you will need
final int LENGTH = 100;
double[] values = new double[LENGTH];
 Use companion variable to keep track of current size: call it
currentSize

 A loop to fill the array
int currentSize = 0;
Scanner in = new Scanner(System.in);
while (in.hasNextDouble())
{
if (currentSize < values.length)
{
values[currentSize] = in.nextDouble();
currentSize++;
}
}
 At the end of the loop, currentSize contains the actual number
of elements in the array.
 Note: Stop accepting inputs when currentSize reaches the
array length.

 To process the gathered array elements, use the companion
variable, not the array length:
for (int i = 0; i < currentSize; i++)
{
System.out.println(values[i]);
}
 With a partially filled array, you need to remember how many
elements are filled.

Self Check 7.1
Answer:
int[] primes = { 2, 3, 5, 7, 11 };
Declare an array of integers containing the first five prime
numbers.

Self Check 7.2
Answer: 2, 3, 5, 3, 2
Assume the array primes has been initialized as described in
Self Check 1. What does it contain after executing the
following loop?
for (int i = 0; i < 2; i++)
{
primes[4 - i] = primes[i];
}

Self Check 7.3
Answer: 3, 4, 6, 8, 12
 Assume the array primes has been initialized as described
in Self Check 1. What does it contain after executing the
following loop?
for (int i = 0; i < 5; i++)
{
primes[i]++;
}

Self Check 7.4
Answer:
values[0] = 10;
values[9] = 10;
or better:
values[values.length - 1] = 10;
Given the declaration
int[] values = new int[10];
write statements to put the integer 10 into the elements of the
array values with the lowest and the highest valid index.

Self Check 7.5
Answer:
String[] words = new String[10];
Declare an array called words that can hold ten elements of
type String.

Self Check 7.6
Answer:
String[] words = { "Yes", "No" };
 Declare an array containing two strings, "Yes", and "No".

Self Check 7.7
Answer: No. Because you don’t store the values, you need
to print them when you read them. But you don’t know
where to add the <= until you have seen all values.
 Can you produce the output on page 312 without storing the inputs in an
array, by using an algorithm similar to the algorithm for finding the maximum
in Section 6.7.5?

Self Check 7.8
Answer:
public class Lottery
{
public int[] getCombination(int n) { . . . }
. . .
}
 Declare a method of a class Lottery that returns a
combination of n numbers. You don’t need to implement the
method.

Make Parallel Arrays into Arrays of Objects
 Don't do this
int[] accountNumbers;
double[] balances;
 Don't use parallel arrays
Figure 4

Make Parallel Arrays into Arrays of Objects
Avoid parallel arrays by changing them into arrays of objects:
BankAccount[] accounts;
Figure 5

The Enhanced for Loop
 You can use the enhanced for loop to visit all elements of an
array.
 Totaling the elements in an array with the enhanced for loop
double[] values = . . .;
double total = 0;
for (double element : values)
{
total = total + element;
}
 The loop body is executed for each element in the array values.
 Read the loop as “for each element in values”.

 Traditional alternative:
{
double element = values[i];
total = total + element;
}

 Not suitable for all array algorithms.
 Does not allow you to modify the contents of an array.
 The following loop does not fill an array with zeros:
{
element = 0;
// ERROR: this assignment does not modify
// array elements
}
 Use a basic for loop instead:
{
values[i] = 0; // OK
}

 Use the enhanced for loop if you do not need the index values
in the loop body.
 The enhanced for loop is a convenient mechanism for
traversing all elements in a collection.

Syntax 7.2 The Enhanced for Loop

Self Check 7.9
Answer: It counts how many elements of values are zero.
What does this enhanced for loop do?
int counter = 0;
{
if (element == 0) { counter++; }
}

Self Check 7.10
Answer:
for (double x : values)
{
System.out.println(x);
}
Write an enhanced for loop that prints all elements in the array
values.

Self Check 7.11
Answer: The loop writes a value into values[i]. The
enhanced for loop does not have the index variable i.
Why is the enhanced for loop not an appropriate shortcut for
the following basic for loop?
{
values[i] = i * i;
}

Common Array Algorithm: Filling
 Fill an array with squares (0, 1, 4, 9, 16, ...):
{
values[i] = i * i;
}

Common Array Algorithm: Maximum or
Minimum
 Finding the maximum in an array
double largest = values[0];
{
if (values[i] > largest)
{
largest = values[i];
}
}
 The loop starts at 1 because we initialize largest with values[0].

Common Array Algorithm: Maximum or
Minimum
 Finding the minimum: reverse the comparison.
 These algorithms require that the array contain at least one
element.

Common Array Algorithm: Element
Separators
 When you display the elements of an array, you usually want to
separate them:
Ann | Bob | Cindy
 Note that there is one fewer separator than there are elements

Common Array Algorithm: Element
Separators
 Print the separator before each element except the initial one
(with index 0):
for (int i = 0; i < names.size(); i++)
{
if (i > 0) { System.out.print(" | "); }
System.out.print(names.value[i]);
}
 To print five elements, you need four separators.

Common Array Algorithm: Linear Search
 To find the position of an element:
• Visit all elements until you have found a match or you have come to the
end of the array
 Example: Find the first element that is equal to 100
int searchedValue = 100;
int pos = 0;
boolean found = false;
while (pos < values.length && !found)
{
if (values[pos] == searchedValue) { found = true; }
else { pos++; }
}
if (found) { System.out.println("Found at position: " + pos); }
else { System.out.println("Not found"); }

Common Array Algorithm: Linear Search
 This algorithm is called a linear search.
 A linear search inspects elements in sequence until a match is
found.
 To search for a specific element, visit the elements and stop
when you encounter the match.

Common Array Algorithm: Removing an
Element
Problem: To remove the element with index pos from the array
values with number of elements currentSize.
 Unordered
1. Overwrite the element to be removed with the last element of the array.
2. Decrement the currentSize variable.
values[pos] = values[currentSize - 1];
currentSize--;

Element
Figure 6 Removing an Element in an Unordered Array

Element
 Ordered array
1. Move all elements following the element to be removed to a lower index.
2. Decrement the variable holding the size of the array.
for (int i = pos + 1; i < currentSize; i++)
{
values[i - 1] = values[i];
}
currentSize--;

Element
Figure 7 Removing an Element in an Ordered Array

Common Array Algorithm: Inserting an
Element
 If order does not matter
1. Insert the new element at the end of the array.
2. Increment the variable tracking the size of the array.
{
currentSize++;
values[currentSize -1 ] = newElement;
}

Element
Figure 8 Inserting an Element in an Unordered Array

Element
 If order matters Increment the variable tracking the size of the array.
1. Move all elements after the insertion location to a higher index.
2. Insert the element.
{
currentSize++;
for (int i = currentSize - 1; i > pos; i--)
{
values[i] = values[i - 1];
}
values[pos] = newElement;
}

Element
Figure 9 Inserting an Element in an Ordered Array

Common Array Algorithm: Swapping
Elements
 To swap two elements, you need a temporary variable.
 We need to save the first value in the temporary variable before
replacing it.
double temp = values[i];
values[i] = values[j];
 Now we can set values[j] to the saved value.
values[j] = temp;

Common Array Algorithm: Swapping
Elements
Figure 10 Swapping Array Elements

Common Array Algorithm: Copying an Array
 Copying an array variable yields a second reference to the
same array:
. . . // Fill array
double[] prices = values;
 To make a true copy of an array, call the Arrays.copyOf method:
double[] prices =
Arrays.copyOf(values, values.length);

Common Array Algorithm: Copying an Array
Figure 11 Copying an Array Reference versus Copying an Array

Common Array Algorithm: Growing an Array
 To grow an array that has run out of space, use the
Arrays.copyOf method to double the length of an array
double[] newValues = Arrays.copyOf(values, 2 * values.length);
values = newValues;

Common Array Algorithm: Growing an Array
Figure 12 Growing an Array

Reading Input
 To read a sequence of arbitrary length:
• Add the inputs to an array until the end of the input has been reached.
• Grow when needed.
double[] inputs = new double[INITIAL_SIZE];
int currentSize = 0;
{
// Grow the array if it has been completely filled
if (currentSize >= inputs.length)
{
inputs = Arrays.copyOf(inputs, 2 * inputs.length); // Grow the inputs array
}
inputs[currentSize] = in.nextDouble(); currentSize++;
}
• Discard unfilled elements.
inputs = Arrays.copyOf(inputs, currentSize);

section_3/LargestInArray.java
1 import java.util.Scanner;
2
3 /**
4 This program reads a sequence of values and prints them, marking the largest value.
5 */
6 public class LargestInArray
7 {
8 public static void main(String[] args)
9 {
10 final int LENGTH = 100;
11 double[] values = new double[LENGTH];
12 int currentSize = 0;
13
14 // Read inputs
15
16 System.out.println("Please enter values, Q to quit:");
17 Scanner in = new Scanner(System.in);
18 while (in.hasNextDouble() && currentSize < values.length)
19 {
20 values[currentSize] = in.nextDouble();
21 currentSize++;
22 }
23
Continued

24 // Find the largest value
25
26 double largest = values[0];
27 for (int i = 1; i < currentSize; i++)
28 {
29 if (values[i] > largest)
30 {
31 largest = values[i];
32 }
33 }
34
35 // Print all values, marking the largest
36
37 for (int i = 0; i < currentSize; i++)
38 {
39 System.out.print(values[i]);
40 if (values[i] == largest)
41 {
42 System.out.print(" <== largest value");
43 }
44 System.out.println();
45 }
46 }
47 }
Continued

Program Run
Please enter values, Q to quit: 34.5 80 115 44.5 Q
34.5
80
115 <== largest value
44.5

Self Check 7.13
Answer:
10
Given these inputs, what is the output of the LargestInArray
program?
20 10 20 Q

Self Check 7.14
Answer:
int count = 0;
for (double x : values)
{
if (x == 0) { count++; }
}
Write a loop that counts how many elements in an array are equal
to zero.

Self Check 7.15
Answer: If all elements of values are negative, then the
result is incorrectly computed as 0.
Consider the algorithm to find the largest element in an array. Why
don’t we initialize largest and i with zero, like this?
double largest = 0;
{
if (values[i] > largest) { largest = values[i]; }
}

Self Check 7.16
Answer:
{
System.out.print(values[i]);
if (i < values.length – 1)
{
System.out.print(" | ");
}
}
Now you know why we set up the loop the other way.
When printing separators, we skipped the separator before the
initial element. Rewrite the loop so that the separator is printed
after each element, except for the last element.

Self Check 7.17
Answer: If the array has no elements, then the program
terminates with an exception.
What is wrong with these statements for printing an array with
separators?
System.out.print(values[0]);
{
System.out.print(", " + values[i]);
}

Self Check 7.18
Answer: If there is a match, then pos is incremented
before the loop exits.
When finding the position of a match, we used a while loop, not a
for loop. What is wrong with using this loop instead?
for (pos = 0; pos < values.length && !found; pos++)
{
if (values[pos] > 100) { found = true; }
}

Self Check 7.19
Answer: This loop sets all elements to values[pos].
When inserting an element into an array, we moved the elements
with larger index values, starting at the end of the array. Why is
it wrong to start at the insertion location, like this?
for (int i = pos; i < currentSize - 1; i++)
{
values[i + 1] = values[i];
}

Problem Solving: Adapting Algorithms
 By combining fundamental algorithms, you can solve complex
programming tasks.
 Problem: Compute the final quiz score by dropping the lowest
and finding the sum of all the remaining scores.
 Related algorithms:
• Calculating the sum
• Finding the minimum value
• Removing an element

 A plan of attack
Find the minimum.
Remove it from the array.
Calculate the sum.
 Try it out. The minimum is 4
 We need to use a linear search to find the position of the
minimum.

 Revise the plan of attack
Find the minimum value.
Find its position.
Remove that position from the array.
Calculate the sum.
 Try it out
• Find the minimum value of 4. Linear search tells us that the value 4
occurs at position 5.
• Remove it
 Compute the sum: 8 + 7 + 8.5 + 9.5 + 7 + 10 = 50.
 This walk-through demonstrates that our strategy works.

 Inefficient to find the minimum and then make another pass
through the array to obtain its position.
 Modify minimum algorithm to remember the position of the
smallest element
int smallestPosition = 0;
{
if (values[i] < values[smallestPosition])
{
smallestPosition = I;
}
}
 Final Strategy
Find the position of the minimum.
Remove it from the array.
Calculate the sum.

Self Check 7.20
Answer: Use the first algorithm. The order of elements
does not matter when computing the sum.
Section 7.3.6 has two algorithms for removing an element. Which
of the two should be used to solve the task described in this
section?

Self Check 7.21
 Answer:
Find the minimum value.
Calculate the sum.
Subtract the minimum value.
It isn’t actually necessary to remove the minimum in order to
compute the total score. Describe an alternative.

Self Check 7.22
Answer: Use the algorithm for counting matches (Section
6.7.2) twice, once for counting the positive values and
once for counting the negative values.
How can you print the number of positive and negative values in a
given array, using one or more of the algorithms in Section 6.7?

Self Check 7.23
Answer: You need to modify the algorithm in Section 7.3.4.
boolean first = true;
{
if (values[i] > 0))
{
if (first) { first = false; }
else { System.out.print(", "); }
}
System.out.print(values[i]);
}
Note that you can no longer use i > 0 as the criterion for
printing a separator.
How can you print all positive values in an array, separated by
commas?

Self Check 7.24
Answer: Use the algorithm to collect all positive elements
in an array, then use the algorithm in Section 7.3.4 to
print the array of matches.
Consider the following algorithm for collecting all matches in an
array:
int matchesSize = 0;
{
if (values[i] fulfills the condition)
{
matches[matchesSize] = values[i];
matchesSize++;
}
}
How can this algorithm help you with Self Check 23?

Problem Solving: Discovering Algorithms by
Manipulating Physical Objects
 Manipulating physical objects can give you ideas for
discovering algorithms.
 The Problem: You are given an array whose size is an even
number, and you are to switch the first and the second half.
 Example
• This array
• will become

 Use a sequence of coins, playing cards, or toys to visualize an
array of values.
 Original line of coins
 Removal of an array element
 Insertion of an array element

 Swapping array elements
 Swap the coins in positions 0 and 4:

 Swap the coins in positions 1 and 5:
 Two more swaps

 The pseudocode
i = 0 j = size / 2
While (i < size / 2)
Swap elements at positions i and j
i++
j++

Self Check 7.25
Answer: The paperclip for i assumes positions 0, 1, 2, 3. When i
is incremented to 4, the condition
i < size / 2
becomes false, and the loop ends. Similarly, the paperclip for j
assumes positions 4, 5, 6, 7, which are the valid positions for
the second half of the array.
Walk through the algorithm that we developed in this section,
using two paper clips to indicate the positions for i and j.
Explain why there are no bounds errors in the pseudocode.

Self Check 7.26
Answer: It reverses the elements in the array.
Take out some coins and simulate the following pseudocode,
using two paper clips to indicate the positions for i and j.
i = 0
j = size – 1
While (i < j)
Swap elements at positions i and j
i++
j--
What does the algorithm do?

Self Check 7.27
Consider the task of rearranging all elements in an array so that
the even numbers come first. Otherwise, the order doesn’t
matter. For example, the array
1 4 14 2 1 3 5 6 23
could be rearranged to
4 2 14 6 1 5 3 23 1
Using coins and paperclips, discover an algorithm that solves this
task by swapping elements, then describe it in pseudocode.
Continued

Self Check 7.27
Answer: Here is one solution. The basic idea is to move all odd
elements to the end. Put one paper clip at the beginning of the array
and one at the end. If the element at the first paper clip is odd, swap
it with the one at the other paper clip and move that paper clip to the
left. Otherwise, move the first paper clip to the right. Stop when the
two paper clips meet. Here is the pseudocode:
i = 0
j = size – 1
While (i < j)
If (a[i] is odd)
Swap elements at positions i and j.
j--
Else
i++

Self Check 7.28
Answer: Here is one solution. The idea is to remove all
odd elements and move them to the end. The trick is to
know when to stop. Nothing is gained by moving odd
elements into the area that already contains moved
elements, so we want to mark that area with another
paper clip.
i = 0
moved = size
While (i < moved)
If (a[i] is odd)
Remove the element at position i and add it at the end.
moved--
 Discover an algorithm for the task of Self Check 27 that uses
removal and insertion of elements instead of swapping.

Self Check 7.29
Answer: When you read inputs, you get to see values one
at a time, and you can’t peek ahead. Picking cards one
at a time from a deck of cards simulates this process
better than looking at a sequence of items, all of which
are revealed.
Consider the algorithm in Section 6.7.5 that finds the largest
element in a sequence of inputs—not the largest element in an
array. Why is this algorithm better visualized by picking playing
cards from a deck rather than arranging toy soldiers in a
sequence?

Two-Dimensional Arrays
 An arrangement consisting of rows and columns of values
• Also called a matrix.
 Example: medal counts of the figure skating competitions at the 2010
Winter Olympics.
Figure 13 Figure Skating Medal counts

 Use a two-dimensional array to store tabular data.
 When constructing a two-dimensional array, specify how many
rows and columns are needed:
final int COUNTRIES = 7;
final int MEDALS = 3;
int[][] counts = new int[COUNTRIES][MEDALS];

 You can declare and initialize the array by grouping each row:
int[][] counts =
{
{ 1, 0, 1 },
{ 1, 1, 0 },
{ 0, 0, 1 },
{ 1, 0, 0 },
{ 0, 1, 1 },
{ 0, 1, 1 },
{ 1, 1, 0 }
};
 You cannot change the size of a two-dimensional array once it
has been declared.

Syntax 7.3 Two-Dimensional Array Declaration

Accessing Elements
 Access by using two index values, array[i][j]
int medalCount = counts[3][1];
 Use nested loops to access all elements in a two-dimensional
array.
 Example: print all the elements of the counts array
for (int i = 0; i < COUNTRIES; i++)
{
// Process the ith row
for (int j = 0; j < MEDALS; j++)
{
// Process the jth column in the ith row
System.out.printf("%8d", counts[i][j]);
}
System.out.println(); // Start a new line at the end of the row
}

Accessing Elements
Figure 14 Accessing an Element in a Two-Dimensional Array

Accessing Elements
 Number of rows: counts.length
 Number of columns: counts[0].length
 Example: print all the elements of the counts array
for (int i = 0; i < counts.length; i++)
{
for (int j = 0; j < counts[0].length; j++)
{
System.out.printf("%8d", counts[i][j]);
}
System.out.println();
}

Locating Neighboring Elements
Figure 15 Neighboring Locations in a Two-Dimensional Array
 Watch out for elements at the boundary array
• counts[0][1] does not have a neighbor to the top

Accessing Rows and Columns
 Problem: To find the number of medals won by a country
• Find the sum of the elements in a row
 To find the sum of the ith row
• compute the sum of counts[i][j], where j ranges from 0 to MEDALS - 1.

 Loop to compute the sum of the ith row
int total = 0;
for (int j = 0; j < MEDALS; j++)
{
total = total + counts[i][j];
}

 To find the sum of the jth column
• Form the sum of counts[i][j], where i ranges from 0 to COUNTRIES – 1
int total = 0;
for (int i = 0; i < COUNTRIES; i++
{
total = total + counts[i][j];
}

section_6/Medals.java
1 /**
2 This program prints a table of medal winner counts with row totals.
3 */
4 public class Medals
5 {
7 {
8 final int COUNTRIES = 7;
9 final int MEDALS = 3;
10
11 String[] countries =
12 {
13 "Canada",
14 "China",
15 "Germany",
16 "Korea",
17 "Japan",
18 "Russia",
19 "United States"
20 };
21
22 int[][] counts =
23 {
24 { 1, 0, 1 },
25 { 1, 1, 0 },
26 { 0, 0, 1 },
27 { 1, 0, 0 },
28 { 0, 1, 1 },
29 { 0, 1, 1 },
30 { 1, 1, 0 }
31 };
32
Continued

33 System.out.println(" Country Gold Silver Bronze Total");
34
35 // Print countries, counts, and row totals
36 for (int i = 0; i < COUNTRIES; i++)
37 {
38 // Process the ith row
39 System.out.printf("%15s", countries[i]);
40
41 int total = 0;
42
43 // Print each row element and update the row total
44 for (int j = 0; j < MEDALS; j++)
45 {
46 System.out.printf("%8d", counts[i][j]);
47 total = total + counts[i][j];
48 }
49
50 // Display the row total and print a new line
51 System.out.printf("%8dn", total);
52 }
53 }
54 }
Continued

Program Run

Self Check 7.30
Answer: You get the total number of gold, silver, and bronze
medals in the competition. In our example, there are four of
each.
What results do you get if you total the columns in our sample
data?

Self Check 7.31
Consider an 8 × 8 array for a board game:
int[][] board = new int[8][8];
Using two nested loops, initialize the board so that
zeros and ones alternate, as on a checkerboard:
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
. . .
1 0 1 0 1 0 1 0
Hint: Check whether i + j is even.
Continued

Self Check 7.31
Answer:
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
board[i][j] = (i + j) % 2;
}
}

Self Check 7.32
Answer:
String[][] board = new String[3][3];
Declare a two-dimensional array for representing a tic-tac-toe
board. The board has three rows and columns and contains
strings "x", "o", and " ".

Self Check 7.33
Answer:
board[0][2] = "x";
Write an assignment statement to place an "x" in the upper-right corner
of the tic-tac-toe board in Self Check 32.

Self Check 7.34
Answer: board[0][0], board[1][1], board[2][2]
Which elements are on the diagonal joining the upper-left and the
lower-right corners of the tic-tac-toe board in Self Check 32?

Array Lists
 An array list stores a sequence of values whose size can
change.
 An array list can grow and shrink as needed.
 ArrayList class supplies methods for many common tasks, such
as inserting and removing elements.
 An array list expands to hold as many elements as needed.

Syntax 7.4 Array Lists

Declaring and Using Array Lists
 To declare an array list of strings
ArrayList<String> names = new ArrayList<String>();
 To use an array list
import java.util.ArrayList;
 ArrayList is a generic class
 Angle brackets denote a type parameter
• Replace String with any other class to get a different array list type

 ArrayList<String> is first constructed, it has size 0
 Use the add method to add an object to the end of the array list:
names.add("Emily"); // Now names has size 1 and element "Emily”
names.add("Bob"); // Now names has size 2 and elements "Emily", "Bob”
names.add("Cindy"); // names has size 3 and elements "Emily", "Bob",
// and "Cindy”
 The size method gives the current size of the array list.
• Size is now 3
Figure 17 Adding an Array List Element with add

 To obtain an array list element, use the get method
• Index starts at 0
 To retrieve the name with index 2:
String name = names.get(2); // Gets the third element
// of the array list
 The last valid index is names.size() - 1
• A common bounds error:
int i = names.size();
name = names.get(i); // Error
 To set an array list element to a new value, use the set method:
names.set(2, "Carolyn");

 An array list has methods for adding and removing elements in
the middle.
 This statement adds a new element at position 1 and moves all
elements with index 1 or larger by one position.
names.add(1, "Ann");

 The remove method,
• removes the element at a given position
• moves all elements after the removed element down by one position
• and reduces the size of the array list by 1.
names.remove(1);
 To print an array list:
System.out.println(names);
// Prints [Emily, Bob, Carolyn]

Figure 18 Adding and Removing Elements in the Middle of an
Array List

Using the Enhanced for Loop with Array
Lists
 You can use the enhanced for loop to visit all the elements of
an array list
ArrayList<String> names = . . . ;
for (String name : names)
{
System.out.println(name);
}
 This is equivalent to:
for (int i = 0; i < names.size(); i++)
{
String name = names.get(i);
System.out.println(name);
}

Copying Array Lists
 Copying an array list reference yields two references to the
same array list.
 After the code below is executed
• Both names and friends reference the same array list to which the string
"Harry" was added.
ArrayList<String> friends = names;
friends.add("Harry");
Figure 19 Copying an Array List Reference

Copying Array Lists
 To make a copy of an array list, construct the copy and pass the
original list into the constructor:
ArrayList<String> newNames =
new ArrayList<String>(names);

Working With Array Lists

Wrapper Classes
 You cannot directly insert primitive type values into array lists.
 Like truffles that must be in a wrapper to be sold, a number
must be placed in a wrapper to be stored in an array list.
 Use the matching wrapper class.

Wrapper Classes
 To collect double values in an array list, you use an
ArrayList<Double>.
 If you assign a double value to a Double variable, the number is
automatically “put into a box”
 Called auto-boxing:
• Automatic conversion between primitive types and the corresponding
wrapper classes:
Double wrapper = 29.95;
• Wrapper values are automatically “unboxed” to primitive types
double x = wrapper;
Figure 20 A Wrapper Class Variable

Using Array Algorithms with Array Lists
 The array algorithms can be converted to array lists simply by
using the array list methods instead of the array syntax.
 Code to find the largest element in an array:
double largest = values[0];
{
if (values[i] > largest) { largest = values[i]; }
}
 Code to find the largest element in an array list:
double largest = values.get(0);
for (int i = 1; i < values.size(); i++)
{
if (values.get(i) > largest) { largest = values.get(i); }
}

Storing Input Values in an Array List
 To collect an unknown number of inputs, array lists are much
easier to use than arrays.
 Simply read the inputs and add them to an array list:
ArrayList<Double> inputs = new ArrayList<Double>();
{
inputs.add(in.nextDouble());
}

Removing Matches
 To remove elements from an array list, call the remove method.
 Error: skips the element after the moved element
ArrayList<String> words = ...;
for (int i = 0; i < words.size(); i++)
{
String word = words.get(i);
if (word.length() < 4)
{
Remove the element at index i.
}
}
 Concrete example

Removing Matches
 Should not increment i when an element is removed
 Pseudocode
If the element at index i matches the condition
Remove the element.
Else
Increment i.

Removing Matches
 Use a while loop, not a for loop
int i = 0;
while (i < words.size())
{
String word = words.get(i);
if (word.length() < 4) { words.remove(i); }
else { i++; }
}

Choosing Between Array Lists and Arrays
 For most programming tasks, array lists are easier to use than
arrays
• Array lists can grow and shrink.
• Arrays have a nicer syntax.
 Recommendations
• If the size of a collection never changes, use an array.
• If you collect a long sequence of primitive type values and you are
concerned about efficiency, use an array.
• Otherwise, use an array list.

Choosing Between Array Lists and Arrays

section_7/LargestInArrayList.java
1 import java.util.ArrayList;
3
4 /**
5 This program reads a sequence of values and prints them, marking the largest value.
6 */
7 public class LargestInArrayList
8 {
10 {
11 ArrayList<Double> values = new ArrayList<Double>();
12
13 // Read inputs
14
15 System.out.println("Please enter values, Q to quit:");
17 while (in.hasNextDouble())
18 {
19 values.add(in.nextDouble());
20 }
21
Continued

22 // Find the largest value
23
24 double largest = values.get(0);
25 for (int i = 1; i < values.size(); i++)
26 {
27 if (values.get(i) > largest)
28 {
29 largest = values.get(i);
30 }
31 }
32
33 // Print all values, marking the largest
34
35 for (double element : values)
36 {
37 System.out.print(element);
38 if (element == largest)
39 {
40 System.out.print(" <== largest value");
41 }
42 System.out.println();
43 }
44 }
45 }
Continued

Program Run
Please enter values, Q to quit:
35 80 115 44.5 Q
35
80
44.5

Self Check 7.35
Answer:
ArrayList<Integer> primes =
new ArrayList<Integer>();
primes.add(2);
primes.add(3);
primes.add(5);
primes.add(7);
primes.add(11);
Declare an array list primes of integers that contains the first five
prime numbers (2, 3, 5, 7, and 11).

Self Check 7.36
Answer:
for (int i = primes.size() - 1; i >= 0; i--)
{
System.out.println(primes.get(i));
}
Given the array list primes declared in Self Check 35, write a loop
to print its elements in reverse order, starting with the last
element.

Self Check 7.37
Answer: "Ann", "Cal"
What does the array list names contain after the following
statements?
ArrayList<String> names = new ArrayList<String>;
names.add("Bob");
names.add(0, "Ann");
names.remove(1);
names.add("Cal");

Self Check 7.38
Answer: The names variable has not been initialized.
What is wrong with this code snippet?
ArrayList<String> names;
names.add(Bob);

Self Check 7.39
Consider this method that appends the elements of one array list to
another:
public void append(ArrayList<String> target,
ArrayList<String> source)
{
for (int i = 0; i < source.size(); i++)
{
target.add(source.get(i));
}
}
What are the contents of names1 and names2 after these statements?
ArrayList<String> names1 = new ArrayList<String>();
names1.add("Emily");
names1.add("Bob");
names1.add("Cindy");
ArrayList<String> names2 = new ArrayList<String>();
names2.add("Dave");
append(names1, names2);
Continued

Self Check 7.39
Answer: names1 contains "Emily", "Bob", "Cindy", "Dave";
names2 contains "Dave"

Self Check 7.40
Answer: Because the number of weekdays doesn’t change,
there is no disadvantage to using an array, and it is easier
to initialize:
String[] weekdayNames = { "Monday", "Tuesday",
"Wednesday", "Thursday", “Friday”, "Saturday",
"Sunday" };
Suppose you want to store the names of the weekdays. Should
you use an array list or an array of seven strings?

Self Check 7.41
Answer: Reading inputs into an array list is much easier.
The ch07/section_7 directory of your source code contains an
alternate implementation of the problem solution in How To 7.1
on page 334. Compare the array and array list
implementations. What is the primary advantage of the latter?

Regression Testing
 Test suite: a set of tests for repeated testing
 Cycling: bug that is fixed but reappears in later versions
 Regression testing: involves repeating previously run tests to
ensure that known failures of prior versions do not appear in
new versions

Regression Testing – Two Approaches
 Organize a suite of test with multiple tester classes: ScoreTester1,
ScoreTester2, …
public class ScoreTester1
{
public static void main(String[] args)
{
Student fred = new Student(100);
fred.addScore(10);
fred.addScore(20);
fred.addScore(5);
System.out.println("Final score: " + fred.finalScore());
System.out.println("Expected: 30");
}
}
 Provide a generic tester, and feed it inputs from multiple files.

section_8/ScoreTester.java
generic tester
2
3 public class ScoreTester
4 {
6 {
8 double expected = in.nextDouble();
9 Student fred = new Student(100);
10 while (in.hasNextDouble())
11 {
12 if (!fred.addScore(in.nextDouble()))
13 {
14 System.out.println("Too many scores.");
15 return;
16 }
17 }
18 System.out.println("Final score: " + fred.finalScore());
19 System.out.println("Expected: " + expected);
20 }
21 }

Input and Output Redirection
 Section_8/input1.txt contains:
30
10
20
5
 Type the following command into a shell window
• Input redirection
java ScoreTester < input1.txt
 Program Run:
Final score: 30
Expected: 30
 Output redirection:
java ScoreTester < input1.txt > output1.txt

Self Check 7.42
Answer: It is possible to introduce errors when modifying
code.
Suppose you modified the code for a method. Why do you want to
repeat tests that already passed with the previous version of
the code?

Self Check 7.43
Answer: Add a test case to the test suite that verifies that the
error is fixed.
Suppose a customer of your program finds an error. What action
should you take beyond fixing the error?

Self Check 7.44
Answer: There is no human user who would see the prompts
because input is provided from a file.
Why doesn't the ScoreTester program contain prompts for the
inputs?

Advanced Programming Lecture 6 Fall 2016

More Related Content

What's hot (20)

Similar to Advanced Programming Lecture 6 Fall 2016 (20)

Recently uploaded (20)

Advanced Programming Lecture 6 Fall 2016