Lecture Notes 06: Intro to Loops

Objectives

By the end of this module, for simple HelloWorld-like programs, you will be able to:

Identify the new syntactic elements with the basic output-only for-loop.
Demonstrate ability to mentally trace execution of for-loops.
Produce desired output using for-loop and println's.
Distinguish between count-up and count-down loops.
Identify the the patterns that may allow the use of a nested for-loop.

Before Starting

Read Sections 6.01 to 6.05 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

Write using Sublime; Compile and run in the Terminal
Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

Numeric Variables: Declaring, assigning and using in operations

Some preliminaries

Bolean Values

Boolean values are true or false. And we'll be using them often in a few weeks.

Since these are a new type of values, then we need another variable type to store them.

That variable type is calle boolean, and it can store either true or false.

in Java, we declare a boolean variable like this:

boolean myBool;

and we can assign them like this:

myBool = false;

or like this:

myBool = true;

And we can also do declaration and assignment in the same line:

boolean myBool = true;

Conditions

Conditions refer to questions that can be asked and that result in either true or false. In other words:

a Condition evaluates to a boolean.

Example: In the sentence "I will give you a slize of pizza if you finish your homework", the condition to be evaluated is "is the homework finished?", which evaluates to either true or false. We'll see the Java version below.

We'll talk more about conditions and Conditionals in a few weeks, bit for now, just remember that a condition is something that is resolved into true or false (which are boolean values).

Loops: the while-loop

An example


  public class PrintCountdown
  {
    public static void main(String args[])     
    {
      // Set up an initial count value
      double count = 10;

      // Now print and decrease it one by one
      System.out.println(count--);  // "--" acts AFTER we resolve the value, so it prints a 10
      System.out.println(count--);  // it prints a 9
      System.out.println(count--);  // it prints a 8
      System.out.println(count--);  // it prints a 7
      System.out.println(count--);  // it prints a 6
      System.out.println(count--);  // it prints a 5
      System.out.println(count--);  // it prints a 4
      System.out.println(count--);  // it prints a 3
      System.out.println(count--);  // it prints a 2
      System.out.println(count--);  // it prints a 1
      System.out.println("Blastoff!");  // it prints Blastoff!
    }
  }

Activity 1: Let's Visualize this execution using our favourite visualizer,
Visualize PrintCountdown.java

This is nice... but. You already know all of this. How is this cool?

Why is this cool?: Because it sets up a couple of the most awesome things you can do in a computer, which is: to automate repetition!.

Let's see this same idea but with a new structure: The while loop:


  public class AwesomePrintCountdown
  {
    public static void main(String args[])     
    {
      // Set up an initial count value
      double count = 10;

      // Now print and decrease it one by one
      while (count > 0)
      {
        System.out.println(count--);
      }
      System.out.println("Blastoff!");  // it prints Blastoff!
    }
  }

The new structure is:

the reserved word while
followed by a condition in perenthesis, in this case "(count > 0)"
follow by a set of statements inside a block surrounded by curly brackets, in this case the print with --

The flow of execution for a while statement is:

Evaluate the condition in parentheses, yielding true or false.
If the condition is false, skip the following statements in braces.
If the condition is true, execute the statements and go back to step 1.

Activity 2: Let's Visualize this execution using our favourite visualizer,
Visualize AwesomePrintCountdown.java

Some issues with the while

Consider the following program and figure out if there is some sort of potential issue:


  public class ForAWhile1
  {
    public static void main(String args[])     
    {
      // Set up an initial count value
      double count = 10;

      // Now print and decrease it one by one
      while (count < 0)
      {
        System.out.println(count--);
      }
      System.out.println("Blastoff!");  // it prints Blastoff!
    }
  }

Now, look at the following program and figure out if there is some sort of potential issue:


  public class ForAWhile2
  {
    public static void main(String args[])     
    {
      // Set up an initial count value
      double count =10;

      // Now print and decrease it one by one
      while (count > 0)
      {
        System.out.println(count++);
      }
      System.out.println("Blastoff!");  // it prints Blastoff!
    }
  }

Finally, check the following program and figure out if there is some sort of potential issue:


  public class ForAWhile3
  {
    public static void main(String args[])     
    {
      // Set up an initial count value
      double count = 10;

      // Now print and decrease it one by one
      while (count > 0)
      {
        System.out.println(count);
      }
      System.out.println("Blastoff!");  // it prints Blastoff!
    }
  }

This last issue is common! Not updating the code that affects the condition may result in trouble!!!

Loops: the for-loop

An example

Consider the following program:

What we would like is a way to organize repetition.

We will do this using a version of the for-loop:

Let's zoom in on the for-loop and dissect it:

First, there is the Java reserved word for:
Note: for emphasis, we have depicted only the loop, in isolation from the rest of the program.
Then, there is the set of conditions:
More about this below.
Next, the body of the loop:
The body includes the opening and closing braces, and whatever lies between the two.
Now, let's drill down further and examine the loop conditions.
The first part is the initialization:
- Think of i as something that "counts".
- Later, we'll see that i is a variable and what we've done is declared and initalized the variable.
- Notice how the initialization part ends with a semicolon.
The second part is the re-entry condition
- Read this as "as long as the condition holds, we'll keep executing the body of the loop".
- Here, the condition is the i must be less than 6.
- Note: this part also ends with a semicolon.
The third part is the change or increment part:
- This part usually changes the counting variable.
- In this case, the counter variable i is increment by one.
- Notice the use of the "increment-by-one" operator ++.
To summarize, when you see
you can read this as: "for i starting at 0, ending at 5, and incrementing by 1 do ... (whatever)"

Printing the loop variable

Consider this example:

Activity 3: Type, compile and execute the above program.

Activity 4: In MyForLoopPrint.java, change the loop conditions so that the numbers 1 through 10 are printed. Also add a print statement after the for-loop, that prints anything.

Observe:

We are able to print out the for-loop variable i.
We see that the loop is executed five times.
⇒ Each time the variable i has increased its value.

Mental execution:

When execution first reaches the for-loop, the initialization condition is executed:
- Say to yourself "i is set to 0".
Important: the initialization condition is not executed again, unless we somehow return to the statement preceding the for-loop.
(We'll see later how this can happen.)
Next, we test the re-entry condition:
- Here, you say to yourself "Is i less than 6?"
- The answer is "yes", so we enter the loop-body and execute what's inside.
Execute (just once) what's inside the loop body:
- In this case the value of i, which is now 0, gets printed out.
After the loop-body has executed, we apply the increment
- Say to yourself "Now i has the value 1".
Next, we test the loop-entry condition:
- Here, you say to yourself "Is i less than 6?"
- It clearly is, so we enter the loop again.
Once again, we execute the loop body:
- Because i has the value 1, this is what gets printed.
Once again, we apply the increment:
- Say to yourself "Now i has the value 2".
Next, apply the entry condition ... and so on.
Finally, after the 5-th time through, i will get the value 6.
- The re-entry condition now fails, and we exit the for-loop.
What "exit" means:
- Execution continues to just after the for-loop.
- In this program, we didn't have anything else, but we could have had:
- In this case, you would print "MOO!" to the screen.
Another way to understand how it works:
The for-loop is one of several such strange and fascinating creatures (structures) we'll encounter in programming.

Variations

To explore for-loops further, we'll look at some variations of the basic for-loop:

First, we could have named our for-loop variable anything we like:
```
    for (int count=0; count<6; count++) {
      printBigO ();
  }
       
```
- It's customary to use short variable names like i and j.
To go through a loop five times, any range of numbers will do:
```
    for (int i=10; i<16; i++) {
      printBigO ();
  }
       
```
- Of course, this doesn't work for printing, unless we want to print values from 10 to 15.
Here's an example of using the <= operator:
```
    for (int i=1; i<=5; i++) {
      printBigO ();
  }
       
```
- Treat <= as one symbol ("less than or equal to").
- We do this because the keyboard doesn't have a symbol for ≤.
Here are different ways of incrementing by 1:
```
    for (int i=0; i<6 i=i+1) {
      printBigO ();
  }

    for (int i=0; i<6; i+=1) {    // Using the += operator.
      printBigO ();
  }
       
```
Activity 5: Write a program to print out the odd numbers from 1 to 25. Use a single for-loop with the appropriate increment and write your code in Odd25.java.
One can count down just as easily:
```
    for (int i=5; i>0; i--) {
      System.out.println (i);
  }
       
```
- Observe the entry-condition is "as long as i>0".

Activity 6: Write a program to print out the odd numbers from 25 down to 1. Write your code in Odd25Down.java.

Nested for-loops

We'll start by writing a program to print a little number triangle like this:

Notice: there's repetition across a row of numbers: a potential use of for-loops!

Here's the program, using for-loops:

Observe:

We've used System.out.print to avoid printing each number on a single line.
System.out.println() merely goes to the next line.
(Or, ends the current line being printed.)

Activity 7: Add a row for 5 (with five of them), writing your code in MyForLoopPrint2.java

Activity 8: Just for the heck of it, could one use a for-loop to achieve the printing of 1? That is, answer the question: can a for-loop be set up so that you go into it exactly once? Write your code in MyForLoopPrint3.java

Identify repetition and try a Nested For Loop

Next, observe that the upper-limits of the for-loops are themselves increasing:

Another way to say this:

    When the value is 2, print a row of 2's
    When the value is 3, print a row of 3's
    When the value is 4, print a row of 4's

Think for next class: Can we use a for loop to automate the upper limits of the for loops themselves?

CS 1111