Chapter 6

Repetition

Asserting Java

© Rick Mercer

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.

Determinate Loops

This template repeats a process n times (you fill in

the comments):

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

FalseLoop test

Iterative part

update-step

True

Example for loop that produces an

average

Scanner keyboard = new Scanner(System.in);

System.out.print("How many do you want to average? ");

int n = keyboard.readInt();

// Do something n times

for(int j = 1; j <= n; j = j + 1) {

System.out.print( "Enter number: " ); // <- Repeat 3

number = keyboard.nextInt( ); // <- statements

sum = sum + number; // <- n times

}

double average = sum / n;

System.out.print( "Average of " + n + " numbers is "

+ average);

Demonstration

Active Learning, Write the output :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 repetitionsfor( int j = 1; j <= n; j++ ) }

// ...

}

The unary ++ and -- operators add 1 and subtract 1 from

their operands, respectively.int n = 0;

n++; // n is now 1 equivalent to n=n+1; or n+=1;

n++; // n is now 2

n--; // n is now 1 again

The expression n++ is equivalent to n = n + 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 a number: ");

x = keyboard.nextInt(); // user enters 7

sum += x;

System.out.print("Enter a number: ");

x = keyboard.nextInt(); // user enters 8

sum += x;

While Loops and

Scanner Objects Constructed

with a String Argument

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

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

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);

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) {

System.out.print (j + " ");

j = j + 2;

}

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

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

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

myGrid.move( );

}

Example Indeterminate Loopneed 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();

}

}

}

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

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;

}