Control Flow

Goals

Understand conditional statements.
Understand loops.

Concepts

control flow
spaghetti code
structured programming

Language

if(…) … else …
switch(…) …
break
continue
do … while(…)
while(…) …
for(…; …; …) …
for( : ) …
assert

Lesson

The programs you've seen up till now have been one-shot applications that go straight through, from beginning to end, with no detours. But what if some of the programming commands are optional? What if you want to repeat a command 100 times without retyping it? You'll need to learn about conditional statements and loops, which govern the control flow of your program. The word “control flow” refers to the “flow of control”, or how control passes from one part of the program to the next.

Decisions

`if(…) … else …`

The most basic conditional statement is if() …, which says, if some condition is true, then do such-and-such.

if(x > 0)
{
  System.out.println("x is positive");
}

Here the part within the parentheses is x > 0, but it could be any boolean expression, such as 5 * 9 != 90 / 2, which in this case evaluates to false so the statement body would not be executed.

If the condition is not true, nothing happens, unless you include the optional else … part of the statement.

if(x > 0)
{
  System.out.println("x is positive");
}
else
{
  System.out.println("x is negative");
  System.out.println("or maybe it is zero");
}

If there is only one statement following the if(…) part or following the else part, Java allows you to leave out the braces { and }. Do not take advantage of this language feature. Leaving off braces is dangerous and causes confusion; standard best practices advise against it. Can you spot the problem in the following code, introduced because braces were left off and the code incorrectly indented?

if(x > 0)
  System.out.println("x is positive");
  System.out.println("x is not zero");

Java does not have an elseif statement, but if you put another if(…) in the body of the else, it functions the same. This is the only place where leaving off the braces of an else statement is acceptable. Do you see how the second if(…) statement is part of the first else statement? How might you reformat this to show the relationship between the else and the second if(…)? The code is completely acceptable as shown, however.

if(x > 0)
{
  System.out.println("x is positive");
}
else if(x == 0)
{
  System.out.println("x is zero");
}
else //no need to check again; there is only one possibility left
{
  assert x < 0 : "Hmmm... x should have been negative here."
  System.out.println("x is negative");
}

The assert statement is a helpful tool to help you, the developer, to double-check your work. As a side benefit, it provides extra documentation to other developers. assert is used with some assumption about the program. Note that the : part of the statement with its string comment is optional.

In the code above, we didn't check the value of x in the third block because there was only one possibility. But we could have made a mistake in our assumption. assert allows us to check the assumption, causing an error condition in the program if your assumption is wrong. The beauty of assert is that it only executes when java is run with the -enableassertions flag. Otherwise the assert statement has no affect on the program. This way you can use -enableassertions during the development of your program, and turn them off in production so that they do not slow down your program. Don't put any “side effects” in the assert expression. For example, don't use assert ++x > 0, which purports to change the value of x.

`switch(…) …`

An if(…) statement now and then works well, but sometimes you have a lot of decisions to make about the same variable or expression.

//not the best approach; better to use the switch() statement

//tells the months in season of the year in the Northern Hemisphere
final String[] months;
if(season.equals("spring"))
{
  months = new Array[]{"March", "April", "May"};
}
else if(season.equals("summer"))
{
  months = new Array[]{"June", "July", "August"};
}
else if(season.equals("fall") || season.equals("autumn")) //note variations accepted
{
  months = new Array[]{"September", "October", "November"};
}
else if(season.equals("winter"))
{
  months = new Array[]{"December", "January", "February"};
}
else
{
  assert false : season;
}

This can quickly get messy—and inefficient. Java has to make decision after decision, evaluating the same expression over and over. A better approach is to use the switch(…) statement, allowing Java to check the expression once and then, using an internal lookup table, quickly go to the correct decision branch in the code. The switch(…) statement always worked with numeric types, and in later versions of Java it works with type String as well. But note that the switch(…) statement only works if you are comparing number or strings for equality. For any other types of expressions, you have to go back to the trusty if(…) statement.

//switch() is a better approach to multiple equality decisions on the same expression

//tells the months in season of the year in the Northern Hemisphere
final String[] months;
switch(season)
{
  case "spring":
    months = new Array[]{"March", "April", "May"};
    break;
  case "summer":
    months = new Array[]{"June", "July", "August"};
    break;
  case "fall":  //note variations accepted
  case "autumn":
    months = new Array[]{"September", "October", "November"};
    break;
  case "winter":
    months = new Array[]{"December", "January", "February"};
    break;
  default:
    assert false : season;
}

Each case of a switch(…) statement must have a break at the end–otherwise it will “fall through” to the next case. This is a handy feature if you want to perform the same action with multiple values. But this aspect of switch(…) is also dangerous. Many a developer has come up with the wrong value because they forgot to add a break to a case.

Note that the variable months is declared on one line but isn't initialized until inside the switch(…) statement. This is perfectly valid; the compiler will make sure that all possible program paths result in the variable months being initialized to some value, or it will complain. This approach works particularly well with variables declared as final.

Loops

If you need to perform some operation multiple times, you could type it in the source code multiple times (or copy and paste). Or you could use one of Java's loop statements. If you need the operation to perform just a little differently each time, use a variable and change it as needed in the loop.

Loops come with a check, either before or at the end, to make sure the loop does not go on forever (unless you want it to). This check functions similar to an if(…) statement. If you need more checks during the loop operation, just add an if(…) statement as needed; if you decide to exit the loop, use a break statement (see below).

Using built-in loops, with occasional break statements to short-circuit operation, is called structured programming. This leads to more understandable and bug-free code, because the control flow is more predictable. Java also has a couple of archaic features that allows you to “go to” certain line numbers, but avoid them. Erratic control flow leads to “spaghetti code” that is harder to understand and more likely to contain errors.

`do … while(…)`

The do ... while(…) loop has a condition at the end. If the condition evaluates to true, the loop repeats at the top until it reaches the end, and then it checks the condition again. This continues until the condition evaluates to false.

The following example adds up the counting numbers until the sum reaches or exceeds the limit. Then it prints how many counting numbers it took to reach that sum.

Winning Number

final int limit = 50;
int sum = 0;
int number = 1;
do
{
  sum += number;  //add the current number to the sum
  number++;  //don't forget to go to the next number
}
while(sum < limit);
final int winningNumber = number - 1;
System.out.println("The counting number needed to attain the sum is " + winningNumber);

Note that at the end we subtract one from number to get the wining number. Why? Because at the end of the loop we increment the number preparing for the next time through the loop. If the expression evaluates to false and we exit the loop, the current number is now one past the number that resulted in the sum passing the mark, so we need to go back to the previous one to show the correct number. How could you rewrite the Winning Number loop, still using do … while(…), so that you would not need to subtract one from number after the loop is finished?

`while(…) …`

A while(…) … statement functions exactly like a do … while(…) statement, except that evaluation of the exit expression occurs before executing the loop body. In fact it might be better named the while(…) do … statement, except that this statement doesn't actually contain the keyword do.

The following algorithm is one way to add up all the numbers in an array of int values:

Array Sum Using while(…)

final int[] array = new int[]{40, 20, 10, 5};
long sum = 0;
int index = 0;
while(index < array.length)
{
  final int element = array[index]; //get the current array element
  sum = sum + element;  //add the current array element to the sum
  index++;  //go to the next array index
}
System.out.println("The sum of the array is " + sum);

Because the exit condition is evaluated at the beginning of the loop, it is possible, if the expression evaluates to false the first time through, that the body of the loop would never execute at all! This is actually more useful than you might think, and is sometimes a benefit of while(…) … over do … while(…). The array in the previous example, could have had a length of zero! Yes, an array can be empty! If you were to use a do … while(…) loop to sum the elements of an array without changing anything else, the first time through the loop Java would tell you that your index is “out of bounds” when you tried to access array[0].

When you become more comfortable with Java, you will probably prefer to combine some of the statements in the body to make the loop more compact:

Compact Array Sum Using while(…)

final int[] array = new int[]{40, 20, 10, 5};
long sum = 0;
int index = 0;
while(index < array.length)
{
  sum += array[index];  //add the current array element to the sum
  index++;  //go to the next array index
}
System.out.println("The sum of the array is " + sum);

Note that advanced programmers could make this loop even more compact by incrementing index at the same time you use it, like this:

sum += array[index++];

This certainly makes the statement compact, but does it make the code more understandable? Note also that now it becomes important whether index has a prefix or postfix notation. If you were accidentally to use ++index, the value of index would be used to look up a value from the array after index was incremented. Only use make your code more compact if you have complete mastery over this concept. If in doubt, remove any chance of error. The compiler will likely ensure that both versions run with the same efficiency.

One thing you should absolutely avoid is removing the braces. If you do decide to make your loop body so compact that it fits into a single line, Java will let you forgo the braces altogether, and even place everything on one line if you wish:

while(index < array.length) sum += array[index++];  //not advised!

While the compiler will recognize this line with no problem, you and your coworkers may not! Leaving braces off leads to errors in the future, when developers misunderstand which statements are part of the loop body and which are not. Always use braces with loops, even when they are optional.

We can use a while(…) … loop to improve the Winning Number solution above. We can add the current number to the sum and check it before even incrementing the number. This way the number will never advance if we have reached the limit, obviating the need to subtract one from the solution.

Better Winning Number

final int limit = 50;
int sum = 0;
int number = 1;
//add the current number to the sum and check it
while((sum += number) < limit)
{
  number++;  //go to the next number
}
System.out.println("The counting number needed to attain the sum is " + number);

Be careful; the expression while((sum += number) < limit) is already starting to become complex. Any more complexity would probably be detrimental to a developer's ability to understand and debug the code.

`for(…; …; …) …`

The for(…; …; …) … statement, commonly referred to as a “for loop”, could be considered a form of “syntactic sugar”: it doesn't add any functionality you couldn't do with a while(…) statement, it just makes setting up the loop much easier. Look again at the Compact Array Sum Using while(…) code snippet above; you'll note that it has three basic sections:

Variable initialization: int index =0
Loop expression: index < array.length
Expression variable update: index++

A for loop is essentially a statement that allows you to combine these three components in a compact way. Here is the Compact Array Sum Using while(…) program again, using a for loop instead of a while(…) statement. Even though the three components of the for loop are presented together on the same line, Java will invoke the components at the correct time, in the same order as in a while(…) statement. That is, the variable initialization occurs once before the loop begins; the loop expression is evaluated at the beginning of the loop each time, and the expression variable is updated at the end of the loop each time (but only if the expression evaluated to true—that is, only if the loop wasn't exited).

Array Sum Using for(…) Loop

final int[] array = new int[]{40, 20, 10, 5};
long sum = 0;
int index;
for(index = 0; index < array.length; index++)
{
  sum += array[index];  //add the current array element to the sum
}
System.out.println("The sum of the array is " + sum);

The for loop allows even variable declaration during the initialization section:

for(int index = 0; index < array.length; index++)
{
  …

One benefit of this is that declaring a variable inside the for(…; …; …) … statement itself limits the scope of that variable to the loop itself. Usually variables used in for loops have no meaning in the larger program itself. Instead they are merely used as “counter” variables in a loop and which serve no purpose after the loop is finished. Restricting the scope of such loop variables to the loop itself protects against accidentally using them once the loop is done. Of course if you need to access the variable after the loop is over (to check to see if the loop had an break before it was complete, for instance), you will have to declare the variable outside the for(…; …; …) … statement as in the example above.

Because loop variables are usually throwaway “counters” used only to iterate through a loop, they are often named i (and j, if two loops are nested) to indicate their temporary use as loop counters. This is an exception to the rule that variable names should not be a single letter and should be meaningful. These names are a convention and other developers will usually recognize their purpose by their names, but you can name them something meaningful as well.

`for( : ) …`

Recent versions of Java have added an “enhanced for loop” that takes the form for( : ) …. The enhanced for loop does not contain three sections to allow for a loop counter. Instead the developer does not need to worry about a loop counter at all, and instead provides the variable that will iterate through the values, and the array containing the values over which to iterate. Compare the following to the Array Sum Using while(…) snippet above.

Array Sum Using Enhanced for(…) Loop

final int[] array = new int[]{40, 20, 10, 5};
long sum = 0;
for(int element : array)
{
  sum += element;
};
System.out.println("The sum of the array is " + sum);

By dispensing with a loop counter in your program, the enhanced for loop greatly reduces the risk of errors. A developer has to ensure that a loop counter is initialized correctly, that it is checked correctly at the correct location in the loop, and that it is incremented correctly at the right place. The last point is especially noteworthy, as almost every programmer will probably forget to increment a loop variable at least once at some point in his or her career. What would happen if you were to forget to increment a loop variable in a traditional loop?

Just as important, the enhanced for loop brings meaning to the variables in the loop. Rather than simply being an almost faceless placeholder, the variable in an enhanced for loop represents the thing that is being iterated in the array. You accordingly can and should provide a meaningful name to the iterating variable in the enhanced for loop.

If you absolutely need a counter to keep track of which item you are on for some reason, you can still use a counter variable with an enhanced for loop. Just declare the counter variable and use it as you would in a while(…) … statement. The enhanced for loop will still provide some protection against errors in the actual iteration of the values, as the counter will be incremented independently of the loop iteration.

In fact Java will generate and use a loop variable behind the scenes when the enhanced for loop executes. But the Java compiler probably makes fewer mistakes than a developer does, and can pretty much be depended on to initialize, test, and increment the loop variable correctly—every single time.

`break`

The break statement, which you used already with switch(…), will exit a loop block just as it does with a switch(…) block. The following example shows how we might exit a loop if the sum were to be larger than some maximum threshold.

Array Sum with break

final int[] array = new int[]{40, 20, 10, 5};
final long max = 50;
long sum = 0;
for(int element : array)
{
  //make sure we don't go over the max
  if(sum + element > max)
  {
    break;  //skip everything else and exit the loop
  }
  sum += element;
};
System.out.println("The sum (kept under max) of the array is " + sum);

`continue`

The continue statement will also skip the rest of the loop, but instead of exiting the loop like break, continue will continue back at the top of the loop for the next cycle. Here is how we could use continue to skip over even numbers.

Array Sum of Odd Numbers Using continue

final int[] array = new int[]{44, 22, 11, 55};
long sum = 0;
for(int element : array)
{
  if(element % 2 == 0)  //if this number is even
  {
    continue;  //skip the rest of the loop and go to the next element
  }
  sum += element;
};
System.out.println("The sum of the odd numbers in the array is " + sum);

Remember that the modulo % operator provides the remainder of a division operation. In element % 2, if there is no remainder when dividing the element by 2, this means the value in the element variable must be even. In skipping the even numbers, we are effectively only adding the odd ones to the sum.

Review

Gotchas

Don't put any “side effects” in an assert expression, because they won't be executed if assertions are turned off.
Make sure you didn't leave out a break at the end of a case in a switch(…) statement, or you could end up with some unintended results!
When you have a loop the expression of which depends on the value of some variable (such as a counter), make sure you remember to update the the variable inside the loop. If the variable never changes, your loop will never ends! No programmer, not even an expert one, is immune to this mistake, so watch for it.

In the Real World

Modern best practice is to use braces for the body of an if(…) statement (except when creating else if) , even if the body consists of a single statement, because the lack of braces can be very confusing—to the developer, not to the compiler. The same goes for the other decision and loop statements that allow a body consisting of a single statement.
Liberally use the assert statement to check assumptions about your calculations as you go along.
If your switch(…) statement purports to exhaust all possibilities, include a default section with assert to ensure that an error is generated if for some reason you didn't account for some value.
Prefer using an enhanced for loop over a traditional for loop, even if you need a counter variable for some reason.

Think About It

Do I have too many if(…) statements checking the equality of the same variable? Maybe a switch(…) statement would be more appropriate.

Self Evaluation

Could you have a statement if(true) …? What would that mean? What about if(false) …? What would happen?
What effect would while(true) … have?
Why is a while(…) … loop sometimes safer or more appropriate than a do … while(…) loop?
Is it guaranteed that the third component of a for(…; …; …) … statement will execute? Why or why not?
In what situation might you use a nested loop (that is, one loop inside another)? If you are using loops with counter variables, what might you name them?
Why is an enhanced for loop considered safer than a traditional for loop? Is an enhanced for loop safer than a traditional for loop even if you need a counter variable?

Task

Create a program named “Booker” to print a list of the best-selling single-volume books with more than 100 million copies sold according to Wikipedia on 2015-08-26.

Name the application class Booker, and place it in a booker subpackage.
- Continue using the same base package for a domain name you own or have control over.
- Make sure you choose a good package name, as you will continue to use it throughout the course.
Provide a Maven build configuration for the program
- Use the same groupId as your base package name.
- Use booker as the artifactId.
- Use the lesson number as the project version. For each of the future lessons, update this version number appropriately. As a best practice you should a -SNAPSHOT version during development, and switch to a release version only when you submit your homework.
In your output include the book names, authors, original language, year published, and approximate sales. Include all titles in their original languages, even if you also provide a translation.
Use arrays to represent the book information in your code. Use as many arrays of as many types as you need, but do not use Java classes for this purpose; you will learn about them in a future lesson.

Send your entire project to your teacher as a single, compressed archive.

Control Flow

Goals

Concepts

Language

Lesson

Decisions

`if(…) … else …`

`switch(…) …`

Loops

`do … while(…)`

`while(…) …`

`for(…; …; …) …`

`for( : ) …`

`break`

`continue`

Review

Gotchas

In the Real World

Think About It

Self Evaluation

Task

See Also

References