Transcript Asserting Java, Ch 7: Repetition

Determinate Loop Pattern, Java's
for Statement, and Scanner objects
2nd part of Chapter 6: Repetition
Algorithmic Pattern:
The Determinate loop
 We often need to perform some action a specific
number of times:
—
—
—
Produce 89 paychecks
Count down to 0 (take 1 second of the clock).
Simulate playing a game of "Let's Make a Deal"
10,000 times
 The determinate loop pattern repeats some action
a specific number of times
Pattern:
Determinate Loop
Problem: Do something exactly n times, where n is known in
advance.
Algorithm determine n
repeat the following n times {
perform these actions
}
int sum
Code
int n =
Example: for(int
sum =
}
// What
= 0;
4;
c = 1; c <= n; c = c + 1) {
sum + c;
is sum now?
Determinate Loops
 This template repeats a process n times
—
replace comments with appropriate statements
int n = /* how often we must repeat the process */
for( int j = 1; j <= n; j = j + 1 ) {
// the process to be repeated
}
 determinate loops must know the number of
repetitions before they begin
• know exactly how many employees, or students, or
whatever that must be processed, for example
General Form
The Java for loop
for ( initial statement ; loop-test ; update-step) {
repeated-part
}
—
When a for loop is encountered, the initial-statement is
executed (used here quite often as int j = 1). The
loop-test evaluates. If loop-test is false, the for loop
terminates. If loop-test is true, the repeated-part
executes followed by the update-step.
Flow chart view of a for loop
Initial statement
True
False
Loop test
Iterative part
update-step
Example for loop that produces an
average
Scanner keyboard = new Scanner(System.in);
double sum = 0.0;
System.out.print("How many do you want to average? ");
int n = keyboard.nextInt();
// Do something n times
for (int j = 1; j <= n; j = j + 1) {
System.out.print("Enter number: "); // <- Repeat 3
int number = keyboard.nextInt(); // <- statements
sum = sum + number; // <- n times
}
double average = sum / n;
System.out.print("Average = " + average);
Code Demo:
Use the debugger to trace this code
int n = 5;
for (int j = 1; j <= n; j = j + 1) {
System.out.println(j);
}
for (int k = 10; k >= 0; k = k - 2) {
System.out.println(k);
}
Other Incrementing Operators
 It is common to see determinate loops of this form
where n is the number of repetitions
for( int j = 1; j <= n; j++ ) }
// ...
}
 The unary ++ and -- operators add 1 and subtract 1
from their operands, respectively.
int n =
n++; //
n++; //
n--; //
0;
n is now 1 equivalent to n=n+1; or n+=1;
n is now 2
n is now 1 again
 The expression count++ is equivalent to the more
verbose count = count + 1;
Other Assignment Operators
 Java has several assignment operators in
addition to = (-= and +=)
j -= 2; is the equivalent of j = j - 2;
sum += x; is the equivalent of sum = sum + x;
 What is sum when a user enters 7 and 8?
int sum = 0;
int x = 0;
System.out.print("Enter
x = keyboard.nextInt();
sum += x;
System.out.print("Enter
x = keyboard.nextInt();
sum += x;
a number: ");
// user enters 7
a number: ");
// user enters 8
Indeterminate loop with a Scanner
Sometimes a stream of input from the
keyboard or a file needs to be read until there
is no more data in the input stream
Consider a Scanner object constructed with a
String argument
—
The string represents an input stream
 You will need Scanner in project 2, methods 9
and 10: sumInScanner and maximumInScanner
These assertions pass
@Test
public void showScanner() {
Scanner scannerWithInts = new Scanner("1 2 3");
assertEquals(1, scannerWithInts.nextInt());
assertEquals(2, scannerWithInts.nextInt());
assertEquals(3, scannerWithInts.nextInt());
Scanner scanner =
new Scanner("There are five words here.");
assertEquals("There", scanner.next());
assertEquals("are", scanner.next());
assertEquals("five", scanner.next());
assertEquals("words", scanner.next());
assertEquals("here.", scanner.next());
}
A test method to test num100s
@Test
public void testNum100s() {
ControlFun cf = new ControlFun();
Scanner scanner0 = new Scanner("1 2 3");
Scanner scanner1 = new Scanner("4 100 2 5");
Scanner scanner3 =
new Scanner("100 100 2 -3 5 3 2 -100 100");
assertEquals(0, cf.num100s(scanner0));
assertEquals(1, cf.num100s(scanner1));
assertEquals(3, cf.num100s(scanner3));
}
Answer
public int num100s (Scanner scanner) {
int result = 0;
while (scanner.hasNextInt()) {
int next = scanner.nextInt();
if (next == 100)
result++;
}
return result;
}
Careful using next too often!
 These assertions should pass with the code that
follows on the next slide
@Test
public void testSumOfNegs() {
ControlFun cf = new ControlFun();
Scanner scanner0 = new Scanner("1 2 3");
Scanner scannerA = new Scanner("1 -2 3");
Scanner scannerB = new Scanner("-4 1 -2 3");
assertEquals(0, cf.sumOfNegatives(scanner0));
assertEquals(-2, cf.sumOfNegatives(scannerA));
assertEquals(-6, cf.sumOfNegatives(scannerB));
}
What's wrong with this method?
public int sumOfNegatives(Scanner scanner) {
int result = 0;
while (scanner.hasNextInt()) {
if (scanner.nextInt() < 0) {
result += scanner.nextInt();
}
}
return result;
}