Control Structures
Control structures are programming blocks that can change the path we take through those
instructions.
There are three kinds of control structures:
Conditional Branches, which we use for choosing between two or more paths. There
are three types in Java: if/else/else if, ternary operator and switch.
Loops that are used to iterate through multiple values/objects and repeatedly run
specific code blocks. The basic loop types in Java are for, while and do while.
Branching Statements, which are used to alter the flow of control in loops. There are
two types in Java: break and continue.
If/Else/Else If
The if/else statement is the most basic of control structures, but can also be
considered the very basis of decision making in programming.
While if can be used by itself, the most common use-scenario is choosing between
two paths with if/else:
if (count > 2) {
[Link]("Count is higher than 2");
} else {
[Link]("Count is lower or equal than 2");
}
Theoretically, we can infinitely chain or nest if/else blocks but this will hurt code
readability, and that's why it's not advised.
Ternary Operator
We can use a ternary operator as a shorthand expression that works like
an if/else statement.
Let's see our if/else example again:
if (count > 2) {
[Link]("Count is higher than 2");
} else {
[Link]("Count is lower or equal than 2");
}
We can refactor this with a ternary as follows:
[Link](count > 2 ? "Count is higher than 2" : "Count is lower or equal than
2");
While ternary can be a great way to make our code more readable, it isn't always a good
substitute for if/else.
Switch
If we have multiple cases to choose from, we can use a switch statement.
Let's again see a simple example:
int count = 3;
switch (count) {
case 0:
[Link]("Count is equal to 0");
break;
case 1:
[Link]("Count is equal to 1");
break;
default:
[Link]("Count is either negative, or higher than 1");
break;
}
Three or more if/else statements can be hard to read. As one of the possible workarounds,
we can use switch, as seen above.
Loops
We use loops when we need to repeat the same code multiple times in succession.
Let's see a quick example of comparable for and while type of loops:
for (int i = 1; i <= 50; i++)
{
methodToRepeat();
}
int whileCounter = 1;
while (whileCounter <= 50)
{
methodToRepeat();
whileCounter++;
}
Both code blocks above will call methodToRepeat 50 times.
Break
We need to use break to exit early from a loop.
Example:
List<String> names = getNameList();
String name = "John Doe";
int index = 0;
for ( ; index < [Link]; index++) {
if (names[index].equals(name)) {
break;
}
}
Here, we are looking for a name in a list of names, and we want to stop looking once
we've found it.
A loop would normally go to completion, but we've used break here to short-circuit that
and exit early.
Continue
Simply put, continue means to skip the rest of the loop we're in:
List<String> names = getNameList();
String name = "John Doe";
String list = "";
for (int i = 0; i < [Link]; i++) {
if (names[i].equals(name)) {
continue;
}
list += names[i];
}
Here, we skip appending the duplicate names into the list.
As we've seen here, break and continue can be handy when iterating, though they
can often be rewritten with return statements or other logic.