1. Chapter 5: Control Structures II
Java Programming:
From Problem Analysis to Program Design,

2. Chapter Objectives
Learn about repetition (looping) control structures.
Explore how to construct and use count-controlled, sentinel-controlled, flag-controlled, and EOF-controlled repetition structures.
Examine break and continue statements.
Discover how to form and use nested control structures.
Java Programming: From Problem Analysis to Program Design

3. Why Is Repetition Needed?
There are many situations in which the same statements need to be executed several times.
Example:
Formulas used to find average grades for students in a class.
Java Programming: From Problem Analysis to Program Design

4. The while Looping (Repetition) Structure
Syntax:
while (expression)
statement
Expression is always true in an infinite loop.
Statements must change value of expression to false.
Java Programming: From Problem Analysis to Program Design

5. The while Looping (Repetition) Structure
Example 5-1
i = 0; //Line 1
while (i <= 20) //Line 2 {
System.out.print(i + " "); //Line 3
i = i + 5; //Line 4 }
System.out.println(); //Line 5
Output
Java Programming: From Problem Analysis to Program Design

6. The while Looping (Repetition) Structure
Typically, while loops are written in the following form:
//initialize the loop control variable(s)
while (expression) //expression tests the LCV { .
//update the loop control variable(s) }
Java Programming: From Problem Analysis to Program Design

7. Counter-Controlled while Loop
Used when exact number of data or entry pieces is known.
General form:
int N = //value input by user or specified
//in program
int counter = 0;
while (counter < N) { .
counter++; }
Java Programming: From Problem Analysis to Program Design

8. Sentinel-Controlled while Loop
Used when exact number of entry pieces is unknown, but last entry (special/sentinel value) is known.
General form:
Input the first data item into variable;
while (variable != sentinel) { .
input a data item into variable; }
Java Programming: From Problem Analysis to Program Design

9. Flag-Controlled while Loop
Boolean value used to control loop.
General form:
boolean found = false;
while (!found) { .
if (expression)
found = true; }
Java Programming: From Problem Analysis to Program Design

10. EOF(End of File)-Controlled while Loop
Used when input is from files.
Sentinel value is not always appropriate.
In an EOF-controlled while loop that uses the Scanner object console to input data, console acts at the loop control variable.
The method hasNext, of the class Scanner, returns true if there is an input in the input stream; otherwise, it returns false.
The expression console.hasNext() acts as the loop condition.
Expressions such as console.nextInt() update the value of the loop condition.
Java Programming: From Problem Analysis to Program Design

11. EOF-Controlled while Loop
A general form of the EOF-controlled while loop that uses the Scanner object console to input data is:
while (console.hasNext()) {
//Get the next input and store in an
//appropriate variable
//Process data }
Java Programming: From Problem Analysis to Program Design

12. Example 5-8: Class Average
// This program reads data from keyboard consisting of students’ // names and their test scores. The program outputs each // student’s name followed by the test score and the grade. The // program also outputs the average test score for all students. import java.io.*; //Line 1 import java.util.*; //Line 2 public class ClassAverage //Line 3 { //Line 4 public static void main(String[] args) //Line 5 { //Line 6 String firstName; //Line 7 String lastName; //Line 8 double testScore; //Line 9 char grade = ' '; //Line 10 double classAverage; //Line 11 double sum = 0; //Line 12 int count = 0; //Line 13
Java Programming: From Problem Analysis to Program Design

13. Scanner input = new Scanner(System. in); //Line 14 while (input
Scanner input = new Scanner(System.in); //Line while (input.hasNext()) //Line { System.out.println(" Enter Students' first name,last name,test score ( press Ctrl+Z when finish):"); //Line firstName = input.next();//read the first name Line lastName = input.next(); //read the last name Line testScore = input.nextDouble(); //read the test score Line sum = sum + testScore; //update sum Line count++; //increment count Line 22
Java Programming: From Problem Analysis to Program Design

14. //determine the grade switch ((int) testScore / 10) //Line { //Line case 0: //Line case 1: //Line case 2: //Line case 3: //Line case 4: //Line case 5: //Line grade = 'F'; //Line break; //Line case 6: //Line grade = 'D'; //Line break; //Line case 7: //Line grade = 'C'; //Line break; //Line case 8: //Line grade = 'B'; //Line break; //Line case 9: //Line case 10: //Line grade = 'A'; //Line break; //Line default: //Line System.out.println("Invalid score."); //Line }//end switch //Line 48
Java Programming: From Problem Analysis to Program Design

15. System. out. printf("%-12s %-12s %4
System.out.printf("%-12s %-12s %4.2f %c %n", firstName, lastName, testScore, grade); //Line }//end while //Line System.out.println(); //Line if (count != 0) //Line System.out.printf("Class Average: %.2f %n", sum / count); //Line else //Line System.out.println("No data."); //Line //Line } //Line 57 }
Java Programming: From Problem Analysis to Program Design

16. Programming Example: Fibonacci Number
Fibonacci formula for any Fibonacci sequence:
an = an-1 + an-2
Input: First two Fibonacci numbers in sequence, position in sequence of desired Fibonacci number (n).
int previous1 = Fibonacci number 1
int previous2 = Fibonacci number 2
int nthFibonacci = Position of nth Fibonacci number
Output: nth Fibonacci number.
Java Programming: From Problem Analysis to Program Design

17. Programming Example: Fibonacci Number (Solution)
if (nthFibonacci == 1)
current = previous1;
else if (nthFibonacci == 2)
current = previous2;
else {
counter = 3;
while (counter <= nthFibonacci)
current = previous2 + previous1;
previous1 = previous2;
previous2 = current;
counter++; }
Final result found in last value of current.
Java Programming: From Problem Analysis to Program Design

18. The for Looping (Repetition) Structure
Specialized form of while loop.
Simplifies the writing of count-controlled loops.
Syntax:
for (initial statement; loop condition;
update statement)
statement
Java Programming: From Problem Analysis to Program Design

19. The for Looping (Repetition) Structure
Execution:
Initial statement executes.
Loop condition is evaluated.
If loop condition evaluates to true, execute for loop statement and execute update statement.
Repeat until loop condition is false.
Java Programming: From Problem Analysis to Program Design

20. The for Looping (Repetition) Structure
Example 5-8
The following for loop prints the first 10 nonnegative integers:
for (i = 0; i < 10; i++)
System.out.print(i + " ");
System.out.println();
Java Programming: From Problem Analysis to Program Design

21. The for Looping (Repetition) Structure
Example 5-9
The following for loop outputs the word Hello and a star (on separate lines) five times:
for (i = 1; i <= 5; i++) {
System.out.println("Hello");
System.out.println("*"); }
2. The following for loop outputs the word Hello five times and the star only once:
Java Programming: From Problem Analysis to Program Design

22. The for Looping (Repetition) Structure
Does not execute if initial condition is false.
Update expression changes value of loop control variable, eventually making it false.
If loop condition is always true, result is an infinite loop.
Infinite loop can be specified by omitting all three control statements.
If loop condition is omitted, it is assumed to be true.
for statement ending in semicolon is empty.
Java Programming: From Problem Analysis to Program Design

23. Programming Example: Classify Numbers
Input: N integers (positive, negative, and zeros).
int N = 20; //N easily modified
Output: Number of 0s, number of even integers, number of odd integers.
Java Programming: From Problem Analysis to Program Design

24. Programming Example: Classify Numbers (Solution)
for (counter = 1; counter <= N; counter++) {
number = console.nextInt();
System.out.print(number + " ");
switch (number % 2)
case 0: evens++;
if (number == 0)
zeros++;
break;
case 1:
case -1: odds++;
} //end switch
} //end for loop
Java Programming: From Problem Analysis to Program Design

25. The do…while Loop (Repetition) Structure
Syntax: do
statement
while (expression);
Statements are executed first and then expression is evaluated.
Statements are executed at least once and then continued if expression is true.
Java Programming: From Problem Analysis to Program Design

26. do…while Loop (Post-Test Loop)
Java Programming: From Problem Analysis to Program Design

27. break Statements Used to exit early from a loop.
Used to skip remainder of switch structure.
Can be placed within if statement of a loop.
If condition is met, loop is exited immediately.
Java Programming: From Problem Analysis to Program Design

28. continue Statements Used in while, for, and do...while structures.
When executed in a loop, the remaining statements in the loop are skipped; proceeds with the next iteration of the loop.
When executed in a while/do…while structure, expression is evaluated immediately after continue statement.
In a for structure, the update statement is executed after the continue statement; the loop condition then executes.
Java Programming: From Problem Analysis to Program Design

29. Nested Control Structures
Provides new power, subtlety, and complexity.
if, if…else, and switch structures can be placed within while loops.
for loops can be found within other for loops.
Java Programming: From Problem Analysis to Program Design

30. Nested Control Structures (Example)
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++)
System.out.print(" *");
System.out.println(); }
Output: * **
***
****
*****
Java Programming: From Problem Analysis to Program Design

31. Chapter Summary Looping mechanisms: Nested control structures
Counter-controlled while loop
Sentinel-controlled while loop
Flag-controlled while loop
EOF-controlled while loop
for loop
do…while loop
break statements
continue statements
Nested control structures
Java Programming: From Problem Analysis to Program Design