CISC 1115 Lecture #9

CISC 1115
Introduction to Programming Using Java
Lecture #9
Loops (Iteration)

Reading from the Text

Chapter 6 Sections 6.1-6.4, 6.6

`while` (Condition-based) Loops

Overview

want to be able to loop as long as some arbitrary condition holds
repeats an action as long as some conditin is true (i.e., until the condition is false)
- searching through a phonebook until a particular name is found
- add cookies to a box until it reaches a certain weight
- flipping a coin until a head appears
- keep prompting user for username/password until it matches an entry in the login database
general for of iteration/repetition
```
while (condition) 
	loop body
		
```
Again, single vs multi-statement loops (latter requires {}'s)
for loop is based on a count; while loop on a condition
- for loop is thus often called a counting loop
  - In actuality, the for/counting loop is just a special case of a condition-based loop: we're looping while the condition of being less than or equal to the count is true
```
for (int i = m; i <= n; i++)
	…	// loop body
							
```
    is (essentially) the same as:
```
int i = m;
while (i <= n) {
	…	// loop body
	i++;
}
							
```

Initial Values of the Variables in the Loop Header

The variables in the condition of the while loop must have values for the condition to be valid
We must make sure this is true the first time into the loop:
- For example, if we want to read in integers from the keyboard until we encounter a negative number, we might be tempted to write the following:
```
int num;
while (num >= 0) {
	System.out.println("Enter a number (< 0 to end):");
	num = scanner.nextInt();
	// the rest of the loop body — processing 'num'
}
				
```
- the problem is that the first time through the loop, there is no valid value in num
  - One way to see that there is an issue is to notice that normally we would declare num when it is first used — in this case it would be the statement where it is assigned the value from nextInt. However, that would generate a compilation error as the loop header used the value of num which must therefore be declared earlier.
  - Coding it as we do above generates a compilation error in Java, as the language requires all local variables be initialized prior to first use
There are two basic ways of ensuring that the variables in the loop header have values the first time through.

'Stuffing' Initial Values to Force the First Iteration

The first approach is to 'Stuff' an initial value into the variable(s) that forces execution to enter the loop the very first time:

int num = 0;
while (num >= 0) {
	System.out.println("Enter a number (< 0 to end):");
	num = scanner.nextInt();
	// the rest of the loop body — processing 'num'
}

the idea is to get the ball rolling, and then the loop body will take care of the values of the condition variable for subsequent iterations of the loop.
while this sometimes works, it often does not; for example in the above code, if the first number is read in from the keyboard is -1 (i.e., the user wants to exit immediately without entering any numbers), the correct behavior should be to do nothing (i.e., terminate the loop even before the first iteration); however our code will have already entered the loop, prompted for and processed this first (negative) number even though it's negative. It's only after going back to the top of the loop that we detect the fact the number was negative and exit the loop, but by then its too late — the number has been processed already.
While this technique is not all that useful for our purpose here, it does have its uses in other situations where we wish to ensure that a loop executes at least once
- You can also look up info about the do while loop form — a much less frequent loop construct than the while or for, but one which ensure at least one pass through the loop body.

'Priming the pump'

The standard (and proper) technique is to 'prime the pump', i.e., making sure all variables used in the condition of the loop have proper values the first time the condition is tested. This often requires some of the code that would typically be at the top of the loop body (inputting of variables, for example) to be lifted out of the loop and placed before the header.
```
System.out.println("Enter a number (< 0 to end):");
num = scanner.nextInt();
while (num >= 0) {
	// The loop body — here is where we process num; note the placement of this code before the code to get the next set of values
	System.out.println("Enter a number (< 0 to end):");
	num = scanner.nextInt();
}
		
```
This technique, however, causes a change on the structure of the loop body: with the first set of values assigned BEFORE the loop, we must move the code (within the loop body) that obtains the subsequent values (for the second, third, etc iterations) to the bottom of the loop
- Not doing so would cause the first set of values to be ignored as they would be immediately overwritten by the second set, as you can see here:
```
// This code in INCORRECT!

System.out.println("Enter a number (< 0 to end):");
num = scanner.nextInt();

while (num >= 0) {
	System.out.println("Enter a number (< 0 to end):");  // this properly belongs at the bottom of the loop
	num = scanner.nextInt();
	// the loop body — processing 'num'
}
				
```
- The only code that should be so shifted is that code which was hoisted above the loop header to prime the pump.
  - This is uaually the code needed to populate the variables actually present in the loop header
    - Other variables can be initialized or input within (at the top of) the loop

File & Keyboard I/O Using a Loop

Until now, we have been extremeley limited in reading data both from the keyboard as well as file
- We have restricted ourselves to a fixed number of data item, since we only have for loops with a fixed number of iterations
Now that we have both while and for loops available, we can present more general techniques for reading files containing varying amounts of data.

Header Values

We've been doing this for quite some time (from the beginning actually)

Uses an integer (the header value) that specifies how many items follow (to be read)
Header values are typically processed using a for loop (as we have a count of the number of values to read in)
Upside: no need for a unique trailer value (below)
Downside: requires a precise count of the number of items to be processed

Program 9.1 (header value from file)

Write a program that reads an integer acting as a header value from a file, then reads in that many integers and prints them out

import java.io.*;
import java.util.*;

public class HeaderValue {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("numbers.text"));

                int howMany = scanner.nextInt();

                for (int i = 1; i <= howMany; i++) {
                        int number = scanner.nextInt();
                        System.out.println(number);
                }
        }
}

Trailer Values

A trailer value is a unique value (also known as a sentinel) that indicates the end of the data
Trailer values are typically processed using a while loop (as we are looping on a condition — i.e., read the data and process while it's not the trailer value)
Upside: no need to have a count of the values
Downside: requires a unique value be available for the sentinel

Program 9.2 (trailer value from file)

Write a program that reads words (strings) from a file, until the 'word' **** is input, printing the words as they are read in.

import java.io.*;
import java.util.*;

public class TrailerValue {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("words.text"));

                String name = scanner.next();	// priming the pump
                while (!name.equals("****")) {
                        System.out.println(name);
                        name = scanner.next();
                }
        }
}

Program 9.3 (trailer value from keyboard)

Write a program that prompts the user for exam grades (integers), until a negative number is input, printing the numbers as they are entered.

import java.util.*;

public class TrailerValue {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(System.in);

                System.out.print("Enter a number (-1 to quit): ");	// priming the punp
                int grade = scanner.nextInt();					//      "
                while (grade >= 0) {
                        System.out.println(grade);
                        System.out.print("Enter a number (-1 to quit): ");
                        grade = scanner.nextInt();
                }
        }
}

Notes

Notice the prompt is also part of priming the pump
- Since grade is needed in the condition, we must prime the pump by getting its value
- A prompt must precede the input of grade (we're reading from the keyboard), so it too is part of the priming logic

end-of-file Processing

A form of trailer value, but one supplied by the language's I/O runtime library
- Java's Scanner class provides methods name hasNextxxx (e.g., hasNext, hasNextInt, etc), that parallel the nextxxx methods, and return a boolean (true if there is more data in the file or keyboard, and it is of the specified type).
The typical use is to detect end-of-file
End-of-file processing typically uses a while loop (as we are looping on a condition — end of file not yet encountered)
Upside: not much to do, the information is provided by the language/runtime I/O libraries
Downside: only useful for I/O; typically useful only for the end of the file; requires support by the language

Program 9.4 (reading to end-of-file)

Write a program that reads in integers from a file, printing them out as they are entered.

import java.io.*;
import java.util.*;

public class EOF {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("numbers.text"));

                while (scanner.hasNextInt()) {
                        int number = scanner.nextInt();
                        System.out.println(number);
                }
        }
}

Notes

There is no punp-priming here
- The condition consists of a call to scanner.nextInt; i.e., the condition contains no variables of ours that have to be initialized
- the object referenced by scanner takes care of itself and will be able to respond correctly to our call

end-of-file and the Keyboard

Program 9.5 (reading to end-of-file from the keyboard)

Write a program that reads in integers from the keyboard, printing them out as they are entered.

import java.io.*;
import java.util.*;

public class EOF {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(System.in);

                System.out.print("number? ");
                while (scanner.hasNextInt()) {
                        int number = scanner.nextInt();
                        System.out.println(number);
                        System.out.print("number? ");
                }
        }
}

Notes

End of file processing for the keyboard is basically the same as for a file — the only differencs are:
- there is a prompt for which pump priming is necessary (as presented above for tailer values)
- the user signals end of file (i.e., they're done) by typing Ctl-D (possibly Ctl-Z on Windows)

If We Have eof, Why Use Anything Else?

Reading to eof only works with the real end-of-file. There are times when we need to structure our data with sequences in the middle of our data stream, and when that happens, we need a header or trailer value.

Program 9.6 — Working with Structured Data I

Assume a data file needs to be created containing data of the following form:

Students
- Last name
- First name
- Courses
  - Course code (integer)
  - Grade (char)
- graduating year

Design the format of the file, and write a program that reads in the data and prints it out to standard output

students.text
Weiss Gerald
        1234 A
        3212 B
        0000
2023

Arnow David
        5412 A
        3523 C
        6512 B
        0000
2024

Sokol Dina
        1234 B
        0000
2025

Notes

The above data is by far the most complex we have see yet.
The data consists of two sets of repetitions: students, and courses within each student.
- As we will see below, this translates to a pair of nested loops
A logically related set of data within a data stream is often call a record
- If the record is itself part of a larger related unit, we call it a subrecord
- A single item of data is often called a field (of the record)
- Thus, in the above format, we have a record of student data consisting of last and first name fields and a sequence of course subrecords, and a graduating year field.
- A course subrecord consists of course code and grade fields
  - The outer repetition — the students — can be processed using eof; i.e., keep reading students until there is no more data (a hasNext returns false).
  - The inner loop — course within a student — cannot use eof, we are not at the end of file when we reach the last course of a student, and thus the options are either a header or trailer value.
    - Some sort of hasNext logic could be used; we will avoid that discussion for now
  - We choose a trailer value; we are going to treat the course code as a String, and could use anything that doesn't resemble a valid course code; e.g., **** or 0000 (we assume the latter would not be used as a course code); we choose the latter.
  - In actuality, we would probably have made the courses the last item in the student's record, and pushed the graduating year before it; we formatted the data like this to emphasize the processing of the courses (i.e., to show how to continue processing the student's data were the courses NOT the last item in the record).

import java.io.*;
import java.util.*;

public class ProcessStudentData {
        public static void main(String [] args) throws IOException {
                final String CODE_TRAILER_VALUE = "0000";

                Scanner scanner = new Scanner(new File("students.text"));

                while (scanner.hasNext()) {
                        String last = scanner.next();
                        String first = scanner.next();
                        System.out.println(last + "," + first);

                        String code = scanner.next();
                        while (!code.equals(CODE_TRAILER_VALUE)) {
                                String grade = scanner.next();
                                System.out.println("\t" + code + ": " + grade);
                                code = scanner.next();
                        }

                        int gradYear = scanner.nextInt();
                        System.out.println("Graduating in " + gradYear);
                        System.out.println();
                }
        }
}

Notes

The body of the outer loop processes the student data; the body of the inner loop, the course data

Stdout

Weiss,Gerald
        1234: A
        3212: B
Graduating in 2023

Arnow,David
        5412: A
        3523: C
        6512: B
Graduating in 2024

Sokol,Dina
        1234: B
Graduating in 2025

Program 9.7 — Working with Structured Data II

Assume a data file needs to be created containing data of the following form:

Weather Stations
- Station id (integer)
- Station name (String)
- months
  - month name (String)
  - temp readings
    - reading (integer)

Design the format of the file, and write a program that reads in the data and prints it out to standard output

Other Loop Examples

Program 9.8

Write a program that 'picks' a secret number and allows the user to guess the number, until (s)he guesses correctly.

import java.util.*;

public class GuessingGame {
        public static void main(String [] args) {
                Scanner scanner = new Scanner(System.in);

                final int theNumber = 4;

                System.out.println( "=== Pick a number game ===");

                System.out.print("Enter a number from 1 to 10: ");
                int theGuess = scanner.nextInt();

                while (theGuess != theNumber) {
                        System.out.println( "Nyah yah nyah nyah nyah.... try again");

                        System.out.print("Enter a number from 1 to 10: ");
                        theGuess = scanner.nextInt();
                }

                System.out.println( "You got it right!");
        }
}

Notes

We need to prime the pump to provide a value to theGuess which appears in the condition

Java's Standard Libraries

Java's API (Application Programmer Interface) — Class Documentation

Some of the more commonly-used packages;

io contains classes for handling input/output (I/O): File
lang contains classes dealing with language elements: String, System, Math
util contains various 'useful' classes: Scanner, Random
... and there are many other such packages

Program 9.9

Same as program 9.8, but uses Random.nextInt to choose a random secret number between 1 and 10

import java.util.*;

public class GuessingGame {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);

		Random random = new Random();
		final int theNumber = random.nextInt(10) + 1; 

		System.out.println( "Pick a number game");

		System.out.print("Enter a number from 1 to 10: ");
		int theGuess = scanner.nextInt();

		while (theGuess != theNumber) {
			System.out.println( "Nyah yah nyah nyah nyah.... try again");

			System.out.print("Enter a number from 1 to 10: ");
			theGuess = scanner.nextInt();
		}

		System.out.println( "You got it right!");
	}
}

Random Number Generators with a Seed

Creating and Printing Tables

Program 9.10

Print the 10 x 10 multiplication table

Notes

Need 10 rows; that is a repetition and thus requires a (counting) loop
Each row needs 10 columns; another counting loop, this one within each row
We thus have a loop within a loop; known as a doubly nested loop

public class MultiplicationTable {
        public static void main(String [] args) throws Exception {
                for (int i = 1; i <= 10; i++) {
                        for (int j = 1; j <= 10; j++)
                                System.out.print(i * j + " ");
                        System.out.println();
                }
        }
}

Stdout
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Formatting Tabular Output

Program 9.11

Redo Program 9.10 in a nice, tabular fashion

public class MultiplicationTable {
        public static void main(String [] args) throws Exception {
                for (int i = 1; i <= 10; i++) {
                        for (int j = 1; j <= 10; j++)
                                System.out.printf("%3d ", i * j);
                        System.out.println();
                }
        }
}

Stdout
  1   2   3   4   5   6   7   8   9  10
  2   4   6   8  10  12  14  16  18  20
  3   6   9  12  15  18  21  24  27  30
  4   8  12  16  20  24  28  32  36  40
  5  10  15  20  25  30  35  40  45  50
  6  12  18  24  30  36  42  48  54  60
  7  14  21  28  35  42  49  56  63  70
  8  16  24  32  40  48  56  64  72  80
  9  18  27  36  45  54  63  72  81  90
 10  20  30  40  50  60  70  80  90 100

The `printf` Method

Provides format specifiers; i.e., codes that allow the programmer to control the form of the output, for example, the number of columns to be printed for a value, whether leading zeroes should be printed for numeric values, the number of decimal positions to be printed, etc
form:
```
printf("format", args &hellip)
		
```
- the format consists of:
```
%[flags][width][.precision]conversion
				
```
  where:
  - % is the indicator for an argument conversion item
  - flags modify the output format
    - 0 — 0 padded
    - - — left-justified
    - + — always have a sign
    - ( — parenthesize negative numbers
  - width is the minimum number of characters to be output
  - precision depends on what sort of conversion (don't worry too much about it)
  - conversion is what sort of conversion is to be performed
    - b — boolean (true or false printed)
    - d — integer
    - e — scientific notation
    - g — floating point (decimal or scientific notation)
    - s — string

Eliminating The Nested Loops Using a Method

Nested loops can often be eliminated by introducing a method to handle the inner loop
- Another application of Augenstein's rule
- Another example of procedural decomposition

Program 9.12 — Multiplication Table

Redo Program 9.11 using a method to print a row in the table

public class MultiplicationTable {
        public static void main(String [] args) throws Exception {
                for (int i = 1; i <= 10; i++)
                        doOneRow(i);
        }

        public static void doOneRow(int i) {
                for (int j = 1; j <= 10; j++)
                        System.out.printf("%3d ", i * j);
                System.out.println();
        }
}

eof and Line-oriented Input (`nextLine`)

Program P9.13 — Using a Line Scanner

Input, and then print, the data from a file with the following format:

last-name first-name course-codes …
last-name first-name course-codes …
…

Notes

The student record is formatted on a single line
no header or trailer for the course codes

import java.io.*;
import java.util.*;

public class LineScanner {
        public static void main(String [] args) throws IOException {
                Scanner fileScanner = new Scanner(new File("student.data"));

                while (fileScanner.hasNextLine()) {
                        String line = fileScanner.nextLine();
                        Scanner lineScanner = new Scanner(line);

                        System.out.println(lineScanner.next());         // last name
                        System.out.println(lineScanner.next());         // first name

                        while (lineScanner.hasNextInt()) {
                                int courseCode = lineScanner.nextInt();
                                System.out.println(courseCode);
                        }
                        System.out.println();
                }
        }
}

Multiple Scanners
Have to worry about blank lines, in particular trailing blank lines

The `do`/`while` Loop

There is a third flavor of loop in Java — the do/while loop — (again derived from C/C++), whose frequency of usage is far less than either the for loop or the while loop. The basic syntax is:

do {
	loop body
} while(condition);

Notes

As it's structure implies, the condition is tested at the bottom of the loop; i.e. the loop is executed at least once.
Priming the pump is not much of an issue here as we are executing the loop body before reaching (and testing the condition), and thus any variables used in the condition are generally initialized already (in the loop body)
This loop structure does not allow for situations involving zero iterations; e.g. empty data files.

Applications of the do/while Loop

There are a few (very few) examples that are naturally expressed using a do/while (the zero iteration case is just too prevalent to ignore). A classic one is playing a game; for example our number guessing game. The game is played (the first time), and after it is over, the user is prompted as to whether they wish to play again. The natural and most straightforward to do this is via a do/while:

do {
	play the game
	…
	…

	System.out.print("Want to play again? ");
	String response = scanner.next();
} while (response.equals("Yes"));

Notes

Had the app been structured so that it started off with the prompt "Want to play a game? ", then had the user responded 'No', no game would have been played, i.e., the loop body would not be entered even one time. In such a situation, a while loop would have made more sense (with the condition at top).

Another application is within a particular sorting method … we will encounter it later.

CISC 1115 Introduction to Programming Using Java Lecture #9 Loops (Iteration)

Reading from the Text

Chapter 6

Sections 6.1-6.4, 6.6

while (Condition-based) Loops

Overview

Initial Values of the Variables in the Loop Header

'Stuffing' Initial Values to Force the First Iteration

'Priming the pump'

File & Keyboard I/O Using a Loop

Header Values

Program 9.1 (header value from file)

Trailer Values

Program 9.2 (trailer value from file)

Program 9.3 (trailer value from keyboard)

Notes

end-of-file Processing

Program 9.4 (reading to end-of-file)

Notes

end-of-file and the Keyboard

Program 9.5 (reading to end-of-file from the keyboard)

Notes

If We Have eof, Why Use Anything Else?

Program 9.6 — Working with Structured Data I

students.text

Notes

Notes

Stdout

Program 9.7 — Working with Structured Data II

Other Loop Examples

Program 9.8

Notes

Java's Standard Libraries

Program 9.9

Random Number Generators with a Seed

Creating and Printing Tables

Program 9.10

Notes

Stdout

Formatting Tabular Output

Program 9.11

Stdout

The printf Method

Eliminating The Nested Loops Using a Method

Program 9.12 — Multiplication Table

eof and Line-oriented Input (nextLine)

Program P9.13 — Using a Line Scanner

Notes

The do/while Loop

Applications of the do/while Loop

Files used in this Lecture

Lab for this Lecture

CISC 1115
Introduction to Programming Using Java
Lecture #9
Loops (Iteration)

`while` (Condition-based) Loops

The `printf` Method

eof and Line-oriented Input (`nextLine`)

The `do`/`while` Loop