• Algorithms often need to repeat a step or a sequence of steps
  • Example: Check all batting averages to find the player with the highest
• We often want to apply the same algorithm multiple times
  • Example: Convert multiple speeds in knots to the equivalent speeds in mi/hr (e.g., to create a table)

• It's a pain in the @$$
• It is easy to make a mistake (e.g., omit/repeat a speed)
• The number of repetitions is hard-coded

• It's still a pain in the @$$
• The number of repetitions is still hard-coded

• Some Commonalities:
  • We start by initializing a variable that gets used in one or more calculations
  • We perform the calculation
  • We update the variable that gets used in the calculation
  • We determine if we're done
• What We Would Like:
  • Statements that allow us to do this easily

• Loop:
  • A portion of a program that repeats a statement or group of statements
• Body of a Loop:
  • The statement or group of statements that is repeated
• Iteration:
  • One "pass" through the body of a loop

• Initialization:
  • Entering the track
• Repeated Execution:
  • Running around the track
• Termination:
  • Leaving the track

• Termination/Exit Condition:
  • Can involve a pre-test (i.e., a test at the top) or a post-test (i.e., a test at the bottom)
• Sentinel:
  • A value that would normally be "invalid" that is used to signal that a loop should terminate

• Infinite Loop:
  • A loop that never terminates
  • 
    (Courtesy of Unshelved)
    
• Indefinite Loop:
  • A loop that terminates after a number of iterations that is unknown a priori

• Creation:
  • Prompt a user for multiple values
  • Read multiple values from a file
  • Repeatedly prompt for a single valid input (e.g., when the user might make mistakes)
• Calculation:
  • Perform the same operation on a collection/array of values
  • Sort a collection/array of values
  • Move through "time" or "space" (e.g., in a simulation or game)
  • Searching through a set of possible values (e.g., to find the zero of a function)

• Syntax:
  • while (boolean_expression) statement
• Note:
  • statement can be a simple or block statement

• Properties:
  • Use a pre-test
  • Use a sentinel
• Implications:
  • May have 0 iterations
  • May be infinite
  • May be indefinite

An Example with 0 Iterations

An Example of an Infinite while Loop

An Example of an Indefinite while Loop

• Syntax:
  • do statement while (boolean_expression);
• Note:
  • statement can be a simple or block statement

• Properties:
  • Use a post-test
  • Use a sentinel
• Implications:
  • Must have one iteration
  • May be infinite
  • May be indefinite

• Syntax:
  • for (initialization; boolean_expression; update) statement
• Note:
  • statement can be a simple or block statement

• Properties:
  • Use a pre-test
  • Use a "built-in" initialization
  • Use a "built-in" sentinel
• Implications:
  • May have 0 iterations
  • May be infinite
  • Are most frequently definite (i.e., not indefinite)

• An Observations:
  • Arrays have a known and fixed length so are often processed using for loops
• Example:
  • javaexamples/basics/ForExample2.java (Fragment: 0)
     

• Consider These Examples:
  • for (j=0; j<50; ++j)
  • for (int i=0; i<50; ++i)
• What's Different?
  • The scope of i and j
    
• Why Does It Matter?
  • j can be accessed outside of the loop, i can't
    
• What About the Other Kinds of Loops?
  • The same kind of issue can arise though it is less common

• An Observation:
  • The update pattern is commonly used in loops
• Which Approaches?
  • Explicit updates (e.g., age = age + 1;)
  • Compound assignment operators (e.g., age += 1;)

• Admitting you have a Problem:
  • Look for repeated uses of the same statements/operations/algorithm (i.e., duplication)
• Choosing Between a Loop and a Function/Method:
  • Functions/methods are appropriate when the same statements/operations/algorithm are used in different places
  • Loops are appropriate when the same statements/operations/algorithm appear in one places (e.g., one right after another)
• Constructing the Loop:
  • Carefully identify the repeated/duplicate statements/operations/algorithm
  • Look for the (limited number of) variables that change in the repetitions
  • Identify the way in which those variables change and their initial values
  • Identify the termination condition(s)
• Choosing a Loop:
  • Is the loop definite (prefer for) or indefinite (prefer while or do-while)?
  • Must the loop have at least one iteration (prefer do-while)?