CS 111A Lecture Notes - Loops - Chapter 4

Loops

loop - a way of repeating a block of code while a specified condition is true. Use a loop when you want to repeat a task.
"while" loops have two main formats:
- Condition evaluated at beginning, loop body executes only if condition is true:
```
      while( <condition> )
      {
        <loop body>
      }
    
```
- Condition evaluated at end, loop body always executed at least once, then repeated only if condition is true:
```
      do
      {
        <loop body>
      }while( <condition> );
    
```
Notice the placement of semi-colons above.
Beware of infinite loops!
Notice that "do" cannot stand alone. "do" is only used at the beginning of a do...while loop.
Rules regarding use of curly braces "{" and "}" - If you want more than one line of code in the result/body of an if-statement, else-statement, or loop, then that result/body code must be enclosed by curly braces. They define a block of code with its own scope (We'll learn more about this later.)

Examples of while loops

Invest.java: Here's a program that uses a loop to add up interest on an investment over time
InvestAgain.java: Variation of above Invest program that allows user to repeat the calculation as many times as user wants.
In-class exercise #1: Write a program that outputs "hello" to the user as many times as specified. So ask the user how many times to repeat the greeting, then use a loop to output it that many times. For an extra challenge, alternate between captial and lower-case words, such as:
```
  How many times should I say hello? 5
  hello HELLO hello HELLO hello
```
Hellos.java: Solution to above exercise #1.
Retire.java: another example which calculates results of monthly retirement savings
Eclipse and other IDEs allow you to stop at a breakpoint and step through your code, facilitating debugging.

Advanced Loop Control: break and continue

break - a Java statement that is used only inside a loop or switch structure, to exit that structure and move on with what follows it.
continue - a Java statement that is used only inside a loop, to skip the rest of the loop body, and test the loop condition again, starting a new iteration if the condition is true.
NestedControlStructure.java inputs and shows student info with if-else-if inside loop
NestedAlt.java: Alternate version of above using "break"
In-class exercise #2: Write a program that inputs numbers from the user, using -1 to terminate the input. This is called a sentinal-controlled loop. The program should then display the average of all the numbers, and how many were entered.
AverageNumbers.java: Solution to above in-class exercise #2 to average and count numbers input by user
Input validation is important to avoid errors.
In-class exercise #5: Read this "Security Injection" and do the activities through the "Laboratory Assignment" (You are finished after you show us a complete program to validate all input and calculate BMI.)

For-loops

A for-loop is another loop structure. All loops could be written using while as you've already learned, but some loops are easier to write with a for-loop structure (especially counting loops).
Here is the general template of a for-loop. It consists of 3 parts separated by semi-colons, and a loop body:
```
for(<initialization expression> ; <loop condition> ; <update expression>)
{
  <loop body>
}
  
```
initialization expression - This code is executed only once, before any other part of the loop. Often used to initialize a counting variable, e.g. i = 0
loop condition - This code is executed after the initialization expression. If it evaluates to true then the loop body is executed. If it's false then the loop is finished and the program continues with the next line after the loop's closing curly brace } . Often used to express the boundary for the counting variable, e.g. i < 10
update expression - This code is executed after the loop body each time the loop body is executed. It's often used to increment a counting variable, e.g. i++ Just after the update expression, the loop condition is evaluated, and maybe the loop continues or maybe it stops, depending on the condition's truth or falsehood.
loop body - just like in a while-loop, this is the code that is repeated as long as the condition is true. If there are no curly braces {} then the loop body is the one line of code after the closing parenthesis, ending with a semi-colon. The curly braces allow the loop body to have as many lines as you wish.

So the following code would produce identical behavior to the above loop, using while:

    <initialization expression>;
    while(<loop condition>)
    {
      <loop body>
      <update expression>;
    }

As our programs get more complicated, indentation, formatting, and comments/documentation become more important. Here's a document summarizing and demonstrating best practices in code formatting.
In-class exercise #3: Change the program Invest.java to make it use a for-loop instead of a while loop. (Look closely at the output that's inside the loop!)
InvestFor.java: Solution to above in-class exercise #3. Same as Invest.java, but using a for-loop instead of a while-loop.
RandomExercise.java: Generates random numbers in a loop, stopping when 2 in a row match, outputs largest.

Nested Loops

Loops can be nested, one inside another. If an outer loop repeats x times, and it has an inner loop that repeats y times, how many times does the loop body of the inner loop repeat?
AddMoney.java demonstrates switch statements, for loops, and boolean varaibles

In-class exercise #4: Write nested loops that make a pattern of brackets such as the following:

This program outputs a shape. How wide do you want it? 4
How tall? 3
[][][][]
[][][][]
[][][][]
[cpersiko@fog cs111a]$ java NestedBrackets
This program outputs a shape. How wide do you want it? 2
How tall? 5
[][]
[][]
[][]
[][]
[][]

NestedBrackets.java: Solution to above exercise #4

Return to the main CS 111A page