
Using loops, we can do a statement repeatedly and this can lead to the creation of many complex algorithms.

Now that we have finished branching and conditionals, it's time to add the final element of our algorithm toolbox: 

. Iteration is a way to simplify code that would otherwise be repeated many times in succession. Using loops, we can finally implement complex algorithms and solutions to common problems that we weren't able to before. In this unit, we will learn two types of loops: the 

When we code, we need to make sure that our loops run exactly the number of times that they are supposed to or else, it may just throw you for a loop! We can do this by checking the loop conditions and the incrementation inside our loops. 

Loops can face other problems such as having no end (an 

) or returning the wrong result. We will be learning a method that may help us in making sure our loop works! Combining these with the branching methods we learned in the last unit, we can make many complex algorithms.

, the act of repeating an action or set of actions until a given condition is met. This is done using 

, the control structure that allows you to perform iteration. There are two types used in this unit: the 

. We will learn about a third type, in Unit 6, called the 

The first type of loop we will learn about is the 

. While loops keep running while a condition is true. Here is the anatomy of the while loop:

code before loop
while (condition) {
  do this while the condition is true
}
do this when the condition is no longer true

 is a boolean statement like the ones we learned about in Unit 3, and the 

 follows. In the loop body, the statement is repeated while the condition is true. Once the condition is no longer true, we have 

However, there is another way to exit the loop. If there is a 

 inside the loop body, the loop and method are automatically exited.

When making loops, we can have a problem with the loop condition if it never changes. There are two cases as follows:


If the loop condition is always true, then the loop will never exit, and we are in what is known as an 

. One can be created by setting the condition as just "true" or forgetting to change something in the loop body that makes the condition false. An infinite loop can easily crash a computer and server depending on the program and should be avoided at all costs. If you have run a program and hit an infinite loop, use ctrl+c to stop the program immediately in your programming environment.

If the loop condition is always false, then the loop will never run, and the loop body is just skipped. College Board will sometimes put these conditions on the multiple-choice portion of the exam. But, in practice, this leads to inefficiencies and leads to larger code file sizes than necessary. Thus, we should carefully check the loop conditions to make sure that this doesn't happen.

Using the general structure of a while loop, it is possible to make general templates based on how we want the loop to work. There are different types based on the structure of the while loop condition:

In order to use a fixed number of repetitions, we use an integer set up to be a 

. The general structure of this is as follows:

int i = 0;
while (i < numberOfRepetitions) {
  do something
  i++;
}

, because it increments by 1 every time the loop is run. The line 

 is very important because if it isn't there, the loop condition will always be true and an infinite loop is created.

Variable Number of Repetitions Using A Sentinel

This method is used whenever we want to enter a set of inputs using the Scanner class from the Unit 1 guide. We want the to program to stop asking for inputs when we enter an input that meets a certain criteria. This particular input is called the 

. Here is its structure for a loop that stops if "***" is entered:

import java.util.Scanner;

System.out.print("Enter a list of names, hitting enter/return between each one. \"***\" to stop");
Scanner input = new Scanner(System.in);
String name = input.nextLine();
while(!name.equals("***")) {
  do something
  String name = input.nextLine();
}

Notice how we have the first name inputted before the loop begins and at the end of each iteration instead of the beginning. This is done in order to have an input to check against the sentinel "***". If the sentinel is encountered, then nothing else is done — the loop breaks!

Variable Number of Repetitions Using A Flag

Other times, we don't enter different inputs, but we keep running until a certain action is met inside the loop. This is done using a flag that marks when this condition is met and exits the loop if and when it is met. Here is its structure:

boolean flag = true;
while (flag) {
  do something
  if (some condition is met) {
    flag = false;
  } else {
    keep doing stuff
  }
}

Note how we set the flag to true and only set it to false once the condition is met. Because the flag is now false, the loop will stop as well.

Making Sure Your Loop Works: The Four Loopy Questions

The four loopy questions are a modified version of those taught at Professor David Gries's CS 2110 class taught at Cornell University.

How do we ensure that our loop works correctly? Well here is a set of four questions that may help you with this!

Does my loop make progress towards completion?

Will the method break in the middle of the loop?

Two statements that will help us with loops are the 

 statement will immediately exit out of the loop, no matter if the loop condition is still true. Using this, we can have an alternative code snippet for the flagged loop.

while (true) {
  do something
  if (certain condition is met) {
    do something else
    break;
  }
  do something if condition not met
}

 statement jumps to the next iteration of the loop and doesn't complete the current one. For example, if we want to add all the numbers from 0 to 10 but not include 4, we would do the following:

public static int sampleSum() {
  int i = 0;
  int sum = 0;
  while (i <= 10) {
    if (i == 4) {
      continue;
    }
    sum += i;
  }
  return sum;
}

Try-Catch Statements and Exception Handling

When coding, especially when using loops, we want our code to be 

, meaning that it has to respond correctly and not crash, no matter what input we give it. Normally, if we give invalid input, we will get an InputMismatchException or another error type and the program will crash. Instead, we want our program to continue, or at least end "nicely" where it doesn't instantly crash. This is where we use 

are signs that something is wrong with the code at 

 (when the program is running) and, without 

, the program crashes. There are two types of methods that deal with exception handling. Some methods 

 an exception for other methods to detect. These other methods will do something about this exception so that the program continues smoothly. We will first talk about the former.

, which is when an exception is encountered and the exception is flagged for another method to catch and fix, which is what 

 means. If no other methods have a way to catch the exception, the program crashes.

Meanwhile, other methods can catch exceptions and handle them so that the program doesn't crash. The program tries to run a program assuming that it works correctly in a 

, and if it catches an exception, the program moves to a 

. A method can have multiple catch blocks, each to catch a different type of exception. However, there is a 

 that runs afterwards regardless of what is in the try or catch blocks. Here is the structure of two methods, one which throws an exception and another that catches exceptions.

public static int exceptionThrower() throws InputMismatchException {
  some code
  if (conditionForErrorMet) {
    throw InputMismatchException;
  }
  return 1;
}

public static void exceptionHandler() {
  some code
  try {
    some code that is tried
    int i = exceptionThrower()
  } catch (InputMismatchException i) {
    do something if there is an InputMismatchException
  } catch (Exception e) {
    do something if there is another type of exception
  } finally {
    code that is run regardless
  }
}

Using the building blocks of while loops and some of what we just learned, we can make some algorithms that can do various tasks. Here are some common algorithms illustrated with various code snippets:

Note: This works only for positive numbers and will throw an exception if the inputs do not meet this requirement.

public static boolean divisibility(int number, int divisor) throws NumberFormatException {
  if (number < 0 || divisor <= 0) {
    throw NumberFormatException;
  } else if (number == 0) {
    return true;
  } else {
    while (number > 0) {
      number -= divisor;
    }
    if (number == 0) {
      return true;
    } else {
      return false;
  }
}

Finding the Digits in an Integer From Small to Large Magnitude

Note: This works only for positive numbers and will throw an exception if the input does not meet this requirement.

public static void return digits(int number) throws NumberFormatException {
  while (number != 0) {
    System.out.println(number%10 + " ");
    number /= 10
  }
}

import java.util.Scanner;

public static int determineFrequencyOfEvens() {
  Scanner input = new Scanner(System.in);
  int number;
  int frequency = 0;
  System.out.println("Enter a sequence of integers line by line. Enter 000 to end");
  try {
    number = input.nextInt();
    while (number != 000) {
      if (number % 2 == 0) {
        frequency++:
      }
      number = input.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Invalid input. Terminating input sequence");
  } finally {
    return frequency;
  }
}
      

import java.util.Scanner;

public static int determineFrequencyOfEvens() {
  Scanner input = new Scanner(System.in);
  int number;
  int min;
  System.out.println("Enter a sequence of integers line by line. Enter 000 to end");
  try {
    number = input.nextInt();
    min = number;
    while (number != 000) {
      if (number < min) {
        min = number:
      }
      number = input.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Invalid input. Terminating input sequence");
  } finally {
    return min;
  }
}

import java.util.Scanner;

public static int determineFrequencyOfEvens() {
  Scanner input = new Scanner(System.in);
  int number;
  int max;
  System.out.println("Enter a sequence of integers line by line. Enter 000 to end");
  try {
    number = input.nextInt();
    max = number;
    while (number != 000) {
      if (number > max) {
        max = number:
      }
      number = input.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Invalid input. Terminating input sequence");
  } finally {
    return max;
  }
}

import java.util.Scanner;

public static int determineFrequencyOfEvens() {
  Scanner input = new Scanner(System.in);
  int number;
  int sum = 0;
  System.out.println("Enter a sequence of integers line by line. Enter 000 to end");
  try {
    number = input.nextInt();
    while (number != 000) {
      sum += number;
      number = input.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Invalid input. Terminating input sequence");
  } finally {
    return sum;
  }
}

import java.util.Scanner;

public static int determineFrequencyOfEvens() {
  Scanner input = new Scanner(System.in);
  int number;
  int sum = 0;
  int counter = 0;
  System.out.println("Enter a sequence of integers line by line. Enter 000 to end");
  try {
    number = input.nextInt();
    while (number != 000) {
      sum += number;
      counter ++;
      number = input.nextInt();
    }
  } catch (Exception e) {
    System.out.println("Invalid input. Terminating input sequence");
  } finally {
    return (double) sum / counter;
  }
}

AP Computer Science A Exam

AP CSA Exam Prep 2020 | Reviews + Free Study Help | Fiveable

AP Computer Science A

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

First Unit

Overview of Unit 4: Iteration and 4.1 While Loops

The second type of loop that we will learn is the 

. The for loop allows us to simplify some while loops. Although for loops can be used for any while loop, they are mostly used when the number of repetitions is 

. The most important part of the for loop is the 

 (decrements work here too!) Here is the for loop's anatomy for the "fixed number of repetitions" situation:

for (int i = 0; i < numberOfTimesToRepeat; i++) {
  thing to be repeated
}

. The initialization is done before the loop itself runs, and the incrementer is done at the end of the iteration and before the next. As with while loops, the conditional expression determines when the loop stops.

All for loops can be converted into while loops. For the loop structure above, here would be how we do it:

int i = 0;
while (i < numberOfTimesToRepeat) {
  thing to be repeated
  i++;
}

As we can see, these both do the same thing, but what takes the while loop 5 lines can be simplified to 3 lines in the for loop. For example, here is code that prints the first 10 even numbers as both a for loop and a while loop:

for (int i = 0; i < 10; i++) {
  System.out.println(i * 2);
}

int j = 0;
while (j < 10) {
  System.out.println(j * 2);
  j++;
}

For loops are used for situations where code is run for a fixed number of times. On the other hand, while loops run until a condition is met but don't know when this will happen or how many tries it will take for the loop to exit. For loops are more concise in situations where they can be used, but for loops and while loops for the same situation will take the same time to run. However, while loops in the end are more versatile than for loops with more uses. If there is a situation involving loops that you don't know how to implement at first, first try using while loops, and when you have your solution, see if you can implement it as a for loop.

In Unit 6 and 7, we will learn another important application of for loops — to traverse arrays and ArrayLists.

Using for loops, we can make a program that prints out the first n Fibonacci numbers as follows:

public static void printNFibonacci(int n) {
  int a = 0;
  int b = 1;
  for (int i = 0; i < n; i++) {
    fib = a + b;
    a = b;
    b = fib;
    System.out.println(fib);
  }
}

For Loops

Using for loops, we can also develop many useful algorithms with Strings. There are several that you need to know in this course.

To reverse a string, we need to go get the first character and make it into a String. Then we get the 2nd character and put it before the first character. Then we repeat until all the characters are used up.

public static String reverse(String s) {
  String result = ""
  for (int i = 0; i < string.length(); i++) {
    result = s.substring(i,i+1) + result;
  }
  return result;
}

This can be used to print all characters in the string by setting the length n to 1. To get longer substrings, we increase n to the length of the substrings you want to find. This value can be up to the length of the overall string itself, but no more. This would create an exception. How this algorithm works is similar to a sliding window. The beginning of the window at the beginning of the substring you want to print and the end of the window is the end of the substring. Therefore the width of the rectangle is n. We first set the window to start at the beginning of the string. This corresponds to the loop initialization. Then, the window slides to the right by one character every iteration to represent the loop increment. The loop stops when the end of the window reaches the end of the string. To achieve this, we need the beginning of the window to be less than the length of the string + 1 - n.

public static void printSubstringsLengthN(String s, int n) {
  for (int i = 0; i < (s.length() + 1 - n); i++) {
    System.out.println(s.substring(i, i+n));
  }
}

Developing Algorithms Using Strings

 occurs when we have a loop inside of another loop, similar to nested conditional statements back in Unit 3. Here is the general anatomy:

loopOne {
  loopTwo {
    something
  }
}

When a loop is nested inside another loop, all of the iterations of the inner loop must be completed until the next iteration of the outer loop starts. If there is a break statement inside the inner loop, then it only takes effect in the current iteration of the outer loop. When the next iteration of the outer loop starts, the inner loop starts all over again.

If there are two nested for loops without break statements, and the outer loop runs n times, and the inner loop runs m times for every iteration of the outer loop, then the inner loop will run m*n times. This can be extended to situations where there are more than 2 nested loops. The total number of times the innermost loop is run is the product of the number of times that each loop runs per iteration.

Example: Generating the Next N Prime Numbers After a Certain Number

import java.lang.Math;

public static void printNextNPrimes(int number, int n) {
  currentNumber = number;
  for (int i = 0; i < n; i++) {
    boolean notPrime = true;
    while notPrime {
      currentNumber++;
      notPrime = false;
      for (int i = 2; i < (int) Math.sqrt(currentNumber); i++) {
        if (currentNumber % i == 0) {
          notPrime = true;
          break;
        }
      }
      if (!notPrime) {
        system.out.println(currentNumber);
      }
    }
  }
}

This is a nested iteration with three loops. The outer loop is a for loop that increments whenever a prime number is found until we get to n prime numbers. The middle loop is a while loop that increments the number being checked until it becomes a prime number. Finally, the inner loop is a for loop that checks all possible divisors to see if the number is a prime number or not. In the while loop, we assume that the number is prime, but once the number is found to be not prime in the for loop, the for loop breaks and the boolean notPrime is set to true. If the number is actually not prime, notPrime remains false and the while loop exits.

Nested Iteration

 is done when you want to see how the program is running step by step. This is also known as 

. To do this, go through the code line by line, keeping track of how many times the code runs, all variable values, and what is printed to the console. This is a very important skill to use!

. Debugging is the same as tracing, but it is done on the computer with the IDE of your choice. With debugging, you have a panel that displays the variables in the program and their values in real-time as the program is run. When we use the debugging panel, you can even sometimes change the variable values to see what may happen to the code as well. We can also have 

 in debugging as well. These breakpoints are points that you want the program to manually stop at. This is useful when you want to see the values of different variables at a certain point in the code. After, we can go line-by-line through the rest of the code to see how the variables change or see how the variables change after every iteration of a loop.

A demonstration of breakpoints. Courtesy of 

An example of the debug panel. Courtesy of 

Unit 4: Iteration

AP Computer Science A

all

study guides

blogs

browse by units

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs

Unit 4: Iteration

AP Computer Science A

all

study guides

blogs

browse by units

Free Reviews﻿

Unit 1: Primitive Types﻿

Unit 2: Using Objects﻿

Unit 3: Boolean Expressions and if Statements﻿

Unit 4: Iteration﻿

Unit 5: Writing Classes﻿

Unit 6: Array﻿

Unit 7: ArrayList﻿

Unit 8: 2D Array﻿

Unit 9: Inheritance﻿

Unit 10: Recursion﻿

Blogs﻿

Free Reviews

Unit 1: Primitive Types

Unit 2: Using Objects

Unit 3: Boolean Expressions and if Statements

Unit 4: Iteration

Unit 5: Writing Classes

Unit 6: Array

Unit 7: ArrayList

Unit 8: 2D Array

Unit 9: Inheritance

Unit 10: Recursion

Blogs