Loop blocks

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.

class Count{
publicstaticvoidmain(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 ");
}
}

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:

class Loop{
publicstaticvoidmain(String[]args){
inti;
for(i=1;i<=10;i++){
System.out.println(i+" ");
}
}
}

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 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:

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.

intsquareHigherThan200=0;

while(squareHigherThan200*squareHigherThan200<200){
squareHigherThan200=squareHigherThan200+1;
}

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.

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:

To clarify how a for loop is used, here is an example:

for(inti=1;i<=10;i++){
System.out.println(i);
}

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:

inti=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.

for(inti=1,j=10;i<=10;i++,j--){
System.out.print(i+" ");
System.out.println(j);
}

for(;;){
// Some code
}

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:

String[]sentence={"I","am","a","Java","program."};
for(Stringword:sentence){
System.out.print(word+" ");
}

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:

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.

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.

for(inti=1;i<=10;i++){
System.out.println(i);
if(i==5){
System.out.println("STOP!");
break;
}
}

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:

for(inti=1;i<=10;i++){
if(i==5){
System.out.println("Caught i == 5");
continue;
}
System.out.println(i);
}

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.

intnumberOfItems=5;
intcurrentItems=0;
intcurrentCandidate=1;

while(currentItems<numberOfItems){
currentCandidate=currentCandidate+1;
System.out.println("Test with integer: "+currentCandidate);

booleanfound=true;
for(inti=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);

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

intnumberOfItems=5;
intcurrentItems=0;
intcurrentCandidate=1;

while(currentItems<numberOfItems){
currentCandidate=currentCandidate+1;
System.out.println("Test with integer: "+currentCandidate);

booleanfound=true;
for(inti=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);

intnumberOfItems=5;
intcurrentItems=0;
intcurrentCandidate=1;

while(currentItems<numberOfItems){
currentCandidate=currentCandidate+1;
System.out.println("Test with integer: "+currentCandidate);

booleanfound=true;
for(inti=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);

intnumberOfItems=5;
intcurrentItems=0;
intcurrentCandidate=1;

while(currentItems<numberOfItems){
currentCandidate=currentCandidate+1;
System.out.println("Test with integer: "+currentCandidate);

booleanfound=true;
for(inti=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);

intnumberOfItems=5;
intcurrentItems=0;
intcurrentCandidate=1;

while(currentItems<numberOfItems){
currentCandidate=currentCandidate+1;
System.out.println("Test with integer: "+currentCandidate);

booleanfound=true;
for(inti=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 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:

To break out of or continue with a loop, use the break or continue keyword followed by the name of the loop.

For example:

inti,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+")");
breakOuter;
}
}
}

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.

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:

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.

publicclass Attempt{
publicstaticvoidmain(String[]args){
try{
System.out.println(args[0]);
System.out.println(args[1]);
System.out.println(args[2]);
System.out.println(args[3]);
}catch(ArrayIndexOutOfBoundsExceptione){
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:

The code listing 3.7 receives a number as parameter and print its binary representation.

publicclass GetBinary{
publicstaticvoidmain(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(Stringarg:args){
System.out.println("\t"+arg);
}
}

intnumber=0;
Stringbinary="";

// Get the input number
try{
number=Integer.parseInt(args[0]);
}catch(NumberFormatExceptionex){
System.out.println("Error: argument must be a base-10 integer.");
System.exit(0);
}

// Convert to a binary string
do{
switch(number%2){
case0:binary='0'+binary;break;
case1: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.

importjava.util.*;

publicclass LuckySevens{
publicstaticvoidmain(String[]args){
Scannerin=newScanner(System.in);
Randomrandom=newRandom();
Stringinput;
intstartingCash,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(NumberFormatExceptionex){
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.");
}
}
}

• Book:Java Programming

• Pages using the JsonConfig extension