Lecture Notes 05: Intro to Loops and 1D Arrays

Objectives

• 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.

Why is looping useful in computation?

• Being able to process a batch of survey results to do a study
• Searching through a list of webpages to find the ones that match a keyword
• Creating a countdown for a timer for a shopping cart
• Other examples?

Loops: the while-loop

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

  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!
    }
  }
  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

  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 boolean 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 count--

The flow of execution for a while statement is:

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

Let's take a minute or two to modify the loop to count in the other direction. Note, that one of the most common mistakes people make (myself included!) is forgetting to increment/decrement the counter. If you end up doing this, you'll see what's called an infinite loop, where the loop will go on forever (until you manually hard-exit the program -- this is generally bad).

An infinite loop, especially one that doesn't have a print statement, can look like the computer is "hanging." If you notice this sort of thing, place a print statement in any while loops you have, and it will immediately become obvious what's goig on.

Loops: the for-loop

While loops are great, but they're typically meant to be used when one doesn't know in advance how many times the loop should be executed -- perhaps you want to keep prompting a user to re-enter a password until they pick a valid one:

Java has an alternative to the while loop for cases when you know in advance how many times you want the loop to execute: the for loop.

Consider this example:

Activity 2: Type, compile and execute the above program in the Java Visualizer.

Activity 3: 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. There are many ways to set up a for loop, which we'll explore more in the homework problems and exercises, especially as we combine looping with arrays.

1D arrays: A group-of-items variable

First, recall our "box" analogy for a variable:

• Suppose we declare and assign a value to an int variable i

  

• The variable is like a "box" that can hold one single integer value at a time.

  

An array allows you to create a connected sequences of such boxes:

Let's trace through that example together in the Java Visualizer to understand how arrays are created and updated in memory.

Some items to keep in mind from above:

• You must specify the size of your array upfront. You can either do this by declaring the array and its contents between curly braces (line 7), or specifying the size and filling the array in later (line 10).
• An array can only contain one type of item, which the compiler enforces. We used integers here, but we could have created an array of doubles, or even an array of arrays or more complicated objects (more later!).
• Java will set an empty array (with a known size) to be full of default values. Here, for integers, that default value was 0; for other types, they will have different default values (0.0 for double, false for boolean, and null for strings and other objects).
• Array indicies start at 0 and you cannot index past the end of an array.
• You can get the length of an array using the length field of the array instance.

Activity 4: Modify the code above in the Visualizer to set array2 = array1. What happens?

Keep in mind you can declare an empty array with int[] arr = {};

Arrays and for-loops

Arrays go hand-in-hand with for-loops.

Let's trace through this code together in the Java Visualizer.

Let's trace this through in the Java Visualizer first, and then dive deeper on paper to understand what is going on with memory and how arrays are stored.

Activity 7: What happens when you try to print out your arrays with System.out.println(array1)? Try it out in the Visualizer. Now, print out what System.out.println(array1 == array2) returns. What do you think is going on?

Explaining the strangeness of arrays: a peek under the hood

Let's show how we would trace through the example above on paper; how does Java represent arrays in memory?

Next class:

Assignments for next lecture: