1. Chapter 6
Repetition
Asserting Java
© Rick Mercer 1

2. 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).
Compute grades for 81 students
The determinate loop pattern repeats some action a specific number of times. 2

4. Determinate Loops with while
The determinate loop pattern can be implemented with the Java while loop
This template repeats a process n times:
int n = /* how often we must repeat the process */
int counter = 1; while ( counter <= n ) {
// the process to be repeated
counter = counter + 1; }
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 4

5. Example while loop produces an average
Scanner keyboard = new Scanner(System.in);
double sum = 0.0;
double number;
System.out.print("How many do you want to average? ");
int n = keyboard.nextInt();
int counter = 1;
// Do something n times
while (counter <= n) {
System.out.print("Enter number: "); // <- Repeat 3
number = keyboard.nextDouble(); // <- statements
sum = sum + number; // <- n times
counter = counter + 1; // make sure the loop stops }
double average = sum / n;
System.out.print("Average of "+ n
+ " numbers is "+ average);

6. Active Learning What is the output? : int j = 1; int n = 5;
while(j <= n) {
System.out.print(j + " ");
j = j + 1; }
j = 0;
while(j <= 2 * n) {
j = j + 2;

7. Indeterminate Loops Determinate loops have a limitation
We must know n (the number of repetitions) in advance
Many situations need us to repeat a set of statements an unspecified number of times:
Processing report cards for every student in a school (or paychecks for all employees, or...)
Allowing 1 to many ATM transactions
Asking the user for specific input and allowing re-entry of input after invalid inputs 7

8. Some things that terminate indeterminate loops
An indeterminate loop repeats a process until some stopping event terminates the repetition
There are many such events, but we'll focus on these:
User enters a special value indicating end of data
A logical expression becomes false
The Grid's mover hits the wall or an edge
The end of a file is encountered
Indeterminate loops do not need to know n in advance
Indeterminate loops can actually determine n 8

9. Pattern Indeterminate loop
Problem Some process must repeat an unknown number
of times so some event is needed to terminate the loop.
Algorithm while( the termination event has not occurred ) {
execute several actions1
bring the loop closer to termination }
Code while(dog.frontIsClear()) {
dog.move();
Example }

10. While 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 ControlFun

11. 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()); }

12. Write method average to return the average of the doubles in a Scanner
@Test
public void testNum100s() {
LoopFun cf = new LoopFun();
Scanner scanner1 = new Scanner(" ");
Scanner scanner2 = new Scanner("1.0\t 2\n ");
assertEquals(80.0, cf.average(scanner). 0.01);
assertEquals(2.5, cf.average(scanner). 0.01); }

13. Let sumOfNegatives return the sum of the negative integers in a Scanner
@Test
public void testSumOfNegs() {
ControlFun cf = new ControlFun();
Scanner scanner0 = new Scanner("1 2 3");
Scanner scannerA = new Scanner(" ");
Scanner scannerB = new Scanner(" ");
assertEquals(0, cf.sumOfNegatives(scanner0));
assertEquals(-6, cf.sumOfNegatives(scannerA));
assertEquals(-10, cf.sumOfNegatives(scannerB)); }

14. 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;