# Java Programming/Loop blocks

* Navigate Language Fundamentals topic: ( v • d • e )
* Statements
* Conditional blocks
* Loop blocks
* Boolean expressions
* Variables
* Primitive Types
* Arithmetic expressions
* Literals
* Methods
* String
* Objects
* Packages
* Arrays
* Mathematical functions
* Large numbers
* Random numbers
* Unicode
* Comments
* Keywords
* Coding conventions
* Lambda expressions
Loops are a handy tool that enables programmers to do repetitive tasks with minimal effort. Say we want a program that can count from 1 to 10, we could write the following program.
* Code listing 3.4: Count.java
* class Count {
* public static void main(String args) {
* System.out.println("1 ");
* System.out.println("2 ");
* System.out.println("3 ");
* System.out.println("4 ");
* System.out.println("5 ");
* System.out.println("6 ");
* System.out.println("7 ");
* System.out.println("8 ");
* System.out.println("9 ");
* System.out.println("10 ");
* Output for code listing 3.4
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
The task will be completed just fine, the numbers 1 to 10 will be printed in the output, but there are a few problems with this solution:
* Flexibility: what if we wanted to change the start number or end number? We would have to go through and change them, adding extra lines of code where they're needed.
* Scalability: 10 repeats are trivial, but what if we wanted 100 or even 1000 repeats? The number of lines of code needed would be overwhelming for a large number of iterations.
* Maintenance: where there is a large amount of code, one is more likely to make a mistake.
* Feature: the number of tasks is fixed and doesn't change at each execution.
Using loops we can solve all these problems. Once you get you head around them they will be invaluable to solving many problems in programming.
Open up your editing program and create a new file saved as Loop.java. Now type or copy the following code:
* Code listing 3.5: Loop.java
* class Loop {
* public static void main(String args) {
* int i;
* for (i = 1; i <= 10; i++) {
* System.out.println(i + " ");
* Output for code listing 3.5
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
If we run the program, the same result is produced, but looking at the code, we immediately see the advantages of loops. Instead of executing ten different lines of code, line 5 executes ten times. Ten lines of code have been reduced to just four. Furthermore, we may change the number 10 to any number we like. Try it yourself, replace the 10 with your own number.

### While

while loops are the simplest form of loop. The while loop repeats a block of code while the specified condition is true. Here is the structure of a while loop:
* while (boolean expression$_1$) {
* statement$_1$
* statement$_2$
* statement$_n$
The loop's condition is checked before each iteration of the loop. If the condition is false at the start of the loop, the loop will not be executed at all. The code section 3.28 sets in squareHigherThan200 the smallest integer whose square exceeds 200.
* Code section 3.28: The smallest integer whose square exceeds 200.
* int squareHigherThan200 = 0;
* while (squareHigherThan200 * squareHigherThan200 < 200) {
* squareHigherThan200 = squareHigherThan200 + 1;
* If a loop's condition will never become false, such as if the true constant is used for the condition, said loop is known as an infinite loop. Such a loop will repeat indefinitely unless it is broken out of. Infinite loops can be used to perform tasks that need to be repeated over and over again without a definite stopping point, such as updating a graphics display.

#### Do... while

The do-while loop is functionally similar to the while loop, except the condition is evaluated AFTER the statement executes It is useful when we try to find a data that does the job by randomly browsing an amount of data.
* do {
* statement$_1$
* statement$_2$
* statement$_n$
* } while (boolean expression$_1$);

### For

The for loop is a specialized while loop whose syntax is designed for easy iteration through a sequence of numbers. It consists of the keyword for followed by three extra statements enclosed in parentheses. The first statement is the variable declaration statement, which allows you to declare one or more integer variables. The second is the condition, which is checked the same way as the while loop. Last is the iteration statement, which is used to increment or decrement variables, though any statement is allowed.
This is the structure of a for loop:
* for (variable declarations; condition; iteration statement) {
* statement$_1$
* statement$_2$
* statement$_n$
To clarify how a for loop is used, here is an example:
* Code section 3.29: A for loop.
* for (int i = 1; i <= 10; i++) {
* System.out.println(i);
* Output for code listing 3.29
* 1
* 2
* 3
* 4
* 5
* 6
* 7
* 8
* 9
* 10
The for loop is like a template version of the while loop. The alternative code using a while loop would be as follows:
* Code section 3.30: An iteration using a while loop.
* int i = 1;
* while (i <= 10) {
* System.out.println(i);
* i++;
The code section 3.31 shows how to iterate with the for loop using multiple variables and the code section 3.32 shows how any of the parameters of a for loop can be skipped. Skip them all, and you have an infinitely repeating loop.
* Code section 3.31: The for loop using multiple variables.
* for (int i = 1, j = 10; i <= 10; i++, j--) {
* System.out.print(i + " ");
* System.out.println(j);
* Code section 3.32: The for loop without parameter.
* for (;;) {
* // Some code

#### For-each

Arrays haven't been covered yet, but you'll want to know how to use the enhanced for loop, called the for-each loop. The for-each loop automatically iterates through a list or array and assigns the value of each index to a variable.
To understand the structure of a for-each loop, look at the following example:
* Code section 3.33: A for-each loop.
* String sentence = {"I", "am", "a", "Java", "program."};
* for (String word : sentence) {
* System.out.print(word + " ");
* Output for code section 3.33
* I am a Java program.
The example iterates through an array of words and prints them out like a sentence. What the loop does is iterate through sentence and assign the value of each index to word, then execute the code block.
Here is the general contract of the for-each loop:
* for (variable declaration : array or list) {
* statement$_1$
* statement$_2$
* statement$_n$
Make sure that the type of the array or list is assignable to the declared variable, or you will get a compilation error. Notice that the loop automatically exits after the last item in the collection has been examined in the statement block.
Although the enhanced for loop can make code much clearer, it can't be used in some common situations.
* Only access. Elements can not be assigned to, e.g., not to increment each element in a collection.
* Only single structure. It's not possible to traverse two structures at once, e.g., to compare two arrays.
* Only single element. Use only for single element access, e.g., not to compare successive elements.
* Only forward. It's possible to iterate only forward by single steps.
* At least Java 5. Don't use it if you need compatibility with versions before Java 5.

## Break and continue keywords

The break keyword exits a flow control loop, such as a for loop. It basically breaks the loop.
In the code section 3.34, the loop would print out all the numbers from 1 to 10, but we have a check for when i equals 5. When the loop reaches its fifth iteration, it will be cut short by the break statement, at which point it will exit the loop.
* Code section 3.34: An interrupted for loop.
* for (int i = 1; i <= 10; i++) {
* System.out.println(i);
* if (i == 5) {
* System.out.println("STOP!");
* break;
* Output for code section 3.34
* 1
* 2
* 3
* 4
* 5
* STOP!
The continue keyword jumps straight to the next iteration of a loop and evaluates the boolean expression controlling the loop. The code section 3.35 is an example of the continue statement in action:
* Code section 3.35: A for loop with a skipped iteration.
* for (int i = 1; i <= 10; i++) {
* if (i == 5) {
* System.out.println("Caught i == 5");
* continue;
* System.out.println(i);
* Output for code section 3.35
* 1
* 2
* 3
* 4
* Caught i == 5
* 6
* 7
* 8
* 9
* 10
As the break and continue statements reduce the readability of the code, it is recommended to reduce their use or replace them with the use of if and while blocks. Some IDE refactoring operations will fail because of such statements.
Question 3.2: Consider the following code:
* Question 3.2: Loops and conditions.
* int numberOfItems = 5;
* int currentItems = 0;
* int currentCandidate = 1;
* while (currentItems < numberOfItems) {
* currentCandidate = currentCandidate + 1;
* System.out.println("Test with integer: " + currentCandidate);
* boolean found = true;
* for (int i = currentCandidate - 1; i > 1; i--) {
* // Test if i is a divisor of currentCandidate
* if ((currentCandidate % i) == 0) {
* System.out.println("Not matching...");
* found = false;
* break;
* if (found) {
* System.out.println("Matching!");
* currentItems = currentItems + 1;
* System.out.println("Find the value: " + currentCandidate);
What will be printed in the standard output?
* Output for Question 3.2
* Test with integer: 2
* Matching!
* Test with integer: 3
* Matching!
* Test with integer: 4
* Not matching...
* Test with integer: 5
* Matching!
* Test with integer: 6
* Not matching...
* Test with integer: 7
* Matching!
* Test with integer: 8
* Not matching...
* Test with integer: 9
* Not matching...
* Test with integer: 10
* Not matching...
* Test with integer: 11
* Matching!
* Find the value: 11
The snippet is searching the 5th prime number, that is to say: 11. It iterates on each positive integer from 2 (2, 3, 4, 5, 6, 7, 8, 9, 10, 11...), among them, it counts the prime numbers (2, 3, 5, 7, 11) and it stops at the 5th one.
So the snippet first iterates on each positive integer from 2 using the while loop:
* Answer 3.2.1: while loop.
* int numberOfItems = 5;
* int currentItems = 0;
* int currentCandidate = 1;
* while (currentItems < numberOfItems) {
* currentCandidate = currentCandidate + 1;
* System.out.println("Test with integer: " + currentCandidate);
* boolean found = true;
* for (int i = currentCandidate - 1; i > 1; i--) {
* // Test if i is a divisor of currentCandidate
* if ((currentCandidate % i) == 0) {
* System.out.println("Not matching...");
* found = false;
* break;
* if (found) {
* System.out.println("Matching!");
* currentItems = currentItems + 1;
* System.out.println("Find the value: " + currentCandidate);
For each iteration, the current number is either a prime number or not. If it is a prime number, the code at the left will be executed. If it is not a prime number, the code at the right will be executed.
* Answer 3.2.2: A prime number.
* int numberOfItems = 5;
* int currentItems = 0;
* int currentCandidate = 1;
* while (currentItems < numberOfItems) {
* currentCandidate = currentCandidate + 1;
* System.out.println("Test with integer: " + currentCandidate);
* boolean found = true;
* for (int i = currentCandidate - 1; i > 1; i--) {
* // Test if i is a divisor of currentCandidate
* if ((currentCandidate % i) == 0) {
* System.out.println("Not matching...");
* found = false;
* break;
* if (found) {
* System.out.println("Matching!");
* currentItems = currentItems + 1;
* System.out.println("Find the value: " + currentCandidate);
* Answer 3.2.3: Not a prime number.
* int numberOfItems = 5;
* int currentItems = 0;
* int currentCandidate = 1;
* while (currentItems < numberOfItems) {
* currentCandidate = currentCandidate + 1;
* System.out.println("Test with integer: " + currentCandidate);
* boolean found = true;
* for (int i = currentCandidate - 1; i > 1; i--) {
* // Test if i is a divisor of currentCandidate
* if ((currentCandidate % i) == 0) {
* System.out.println("Not matching...");
* found = false;
* break;
* if (found) {
* System.out.println("Matching!");
* currentItems = currentItems + 1;
* System.out.println("Find the value: " + currentCandidate);
The prime numbers are counted using currentItems. When currentItems is equal to numberOfItems (5), the program go out of the while loop. currentCandidate contains the last number, that is to say the 5th prime number:
* Answer 3.2.4: End of the program.
* int numberOfItems = 5;
* int currentItems = 0;
* int currentCandidate = 1;
* while (currentItems < numberOfItems) {
* currentCandidate = currentCandidate + 1;
* System.out.println("Test with integer: " + currentCandidate);
* boolean found = true;
* for (int i = currentCandidate - 1; i > 1; i--) {
* // Test if i is a divisor of currentCandidate
* if ((currentCandidate % i) == 0) {
* System.out.println("Not matching...");
* found = false;
* break;
* if (found) {
* System.out.println("Matching!");
* currentItems = currentItems + 1;
* System.out.println("Find the value: " + currentCandidate);

## Labels

Labels can be used to give a name to a loop. The reason to do this is so we can break out of or continue with upper-level loops from a nested loop.
Here is how to label a loop:
* label name:loop
To break out of or continue with a loop, use the break or continue keyword followed by the name of the loop.
For example:
* Code section 3.36: A double for loop.
* int i, j;
* int nums = {
* {1, 2, 5},
* {6, 9, 7},
* {8, 3, 4}
* Outer:
* for (i = 0; i < nums.length; i++) {
* for (j = 0; j < nums[i].length; j++) {
* if (nums[i][j] == 9) {
* System.out.println("Found number 9 at (" + i + ", " + j + ")");
* break Outer;
* Output for code section 3.36
* Found number 9 at (1, 1)
You needn't worry if you don't understand all the code, but look at how the label is used to break out of the outer loop from the inner loop. However, as such a code is hard to read and maintain, it is highly recommended not to use labels.

## Try... catch blocks

    See also Throwing and Catching Exceptions.
The try-catch blocks are used to catch any exceptions or other throwable objects within the code.
Here's what try-catch blocks looks like:
* try {
* statement$_{1.1}$
* statement$_{1.2}$
* statement$_{1.n}$
* } catch (exception$_1$) {
* statement$_{2.1}$
* statement$_{2.n}$
The code listing 3.6 tries to print all the arguments that have been passed to the program. However, if there not enough arguments, it will throw an exception.
* Code listing 3.6: Attempt.java
* public class Attempt {
* public static void main(String args) {
* try {
* System.out.println(args[0]);
* System.out.println(args[1]);
* System.out.println(args[2]);
* System.out.println(args[3]);
* } catch (ArrayIndexOutOfBoundsException e) {
* System.out.println("Not enough arguments");
In addition to the try and catch blocks, a finally block may be present. The finally block is always executed, even if an exception is thrown. It may appear with or without a catch block, but always with a try block.
Here is what a finally block looks like:
* try {
* statement$_{1.1}$
* statement$_{1.2}$
* statement$_{1.n}$
* } catch (exception$_1$) {
* statement$_{2.1}$
* statement$_{2.n}$
* } finally {
* statement$_{3.1}$
* statement$_{3.n}$

## Examples

The code listing 3.7 receives a number as parameter and print its binary representation.
* Code listing 3.7: GetBinary.java
* public class GetBinary {
* public static void main(String args) {
* if (args.length == 0) {
* // Print usage
* System.out.println("Usage: java GetBinary <decimal integer>");
* System.exit(0);
* } else {
* // Print arguments
* System.out.println("Received " + args.length + " arguments.");
* System.out.println("The arguments are:");
* for (String arg : args) {
* System.out.println("\t" + arg);
* int number = 0;
* String binary = "";
* // Get the input number
* try {
* number = Integer.parseInt(args[0]);
* } catch (NumberFormatException ex) {
* System.out.println("Error: argument must be a base-10 integer.");
* System.exit(0);
* // Convert to a binary string
* do {
* switch (number % 2) {
* case 0: binary = '0' + binary; break;
* case 1: binary = '1' + binary; break;
* number >>= 1;
* } while (number > 0);
* System.out.println("The binary representation of " + args[0] + " is " + binary);
The code listing 3.8 is a simulation of playing a game called Lucky Sevens. It is a dice game where the player rolls two dice. If the numbers on the dice add up to seven, he wins $4. If they do not, he loses $1. The game shows how to use control flow in a program as well as the fruitlessness of gambling.
* Code listing 3.8: LuckySevens.java
* import java.util.*;
* public class LuckySevens {
* public static void main(String args) {
* Scanner in = new Scanner(System.in);
* Random random = new Random;
* String input;
* int startingCash, cash, maxCash, rolls, roll;
* // Loop until "quit" is input
* while (true) {
* System.out.print("Enter the amount of cash to start with (or \"quit\" to quit): ");
* input = in.nextLine;
* // Check if user wants to exit
* if (input.toLowerCase.equals("quit")) {
* System.out.println("\tGoodbye.");
* System.exit(0);
* // Get number
* try {
* startingCash = Integer.parseInt(input);
* } catch (NumberFormatException ex) {
* System.out.println("\tPlease enter a positive integer greater than 0.");
* continue;
* // You have to start with some money!
* if (startingCash <= 0) {
* System.out.println("\tPlease enter a positive integer greater than 0.");
* continue;
* cash = startingCash;
* maxCash = cash;
* rolls = 0;
* roll = 0;
* // Here is the game loop
* for (; cash > 0; rolls++) {
* roll = random.nextInt(6) + 1;
* roll += random.nextInt(6) + 1;
* if (roll == 7)
* cash += 4;
* else
* cash -= 1;
* if (cash > maxCash)
* maxCash = cash;
* System.out.println("\tYou start with $" + startingCash + ".\n"
* + "\tYou peak at $" + maxCash + ".\n"
* + "\tAfter " + rolls + " rolls, you run out of cash.");