1. Chapter 6 Repetition Asserting Java © Rick Mercer

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.

4. Determinate Loops with while 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 n = /* how often we must repeat the process */ int counter = 1; while ( counter <= n ) { int counter = 1; while ( counter <= n ) { // the process to be repeated // the process to be repeated counter = counter + 1; } 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

5. Example for loop that 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 System.out.print("Enter number: "); // <- Repeat 3 number = keyboard.nextDouble(); // <- statements number = keyboard.nextDouble(); // <- statements sum = sum + number; // <- n times sum = sum + number; // <- n times counter = counter + 1; // make sure the loop stops counter = counter + 1; // make sure the loop stops} double average = sum / n; System.out.print("Average of "+ n + " numbers is "+ average); + " numbers is "+ average);

6. Active Learning  What is the output : int j = 1; int j = 1; int n = 5; int n = 5; while(j <= n) { while(j <= n) { System.out.print (j + " "); System.out.print (j + " "); j = j + 1; j = j + 1; } j = 0; j = 0; while(j <= 2 * n) { while(j <= 2 * n) { System.out.print (j + " "); System.out.print (j + " "); j = j + 2; 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

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

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 these actions bring the loop closer to termination } Code while(myGrid.frontIsClear()) { Example myGrid.move(); }

10. Example Indeterminate Loop need Grid.java Grid.java // Using random robot placement, instruct robot to get to // the wall in front, turn left, and move to the next wall public class MoveAroundTheGrid { public static void main(String[] args) { Grid g = new Grid(10, 15); while (g.frontIsClear()) { g.move(); } g.turnLeft(); while (g.frontIsClear()) { g.move(); } }

11. 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 project 2, methods 9 and 10: sumInScanner and maximumInScanner

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

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

14. Answer public int num100s (Scanner scanner) { int result = 0; while (scanner.hasNextInt()) { int next = scanner.nextInt(); if (next == 100) result++; } return result; }

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

16. 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; }