{"id":2124,"date":"2020-03-16T11:50:09","date_gmt":"2020-03-16T11:50:09","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=2124"},"modified":"2020-03-17T17:37:25","modified_gmt":"2020-03-17T17:37:25","slug":"control-statements-in-java","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/control-statements-in-java\/","title":{"rendered":"Control Statements in Java"},"content":{"rendered":"

You are already familiar with the term statement, which can simply be defined as an instruction given to the computer to perform specific operations. Control Statements in Java are controlling program flow and determining whether the other statements will be executed or not. Java statement<\/a> is a complete unit of execution, terminated with a semicolon.<\/span><\/p>\n

But, imagine you want a statement or a section of code to be executed only under certain conditions that cannot be evaluated until runtime. Or you want a particular segment of code to repeat once for every item in some list.\u00a0<\/span><\/p>\n

They can break up the flow of execution by using decision making, looping, and branching, allowing the application to selectively execute particular segments of code. Control flow statements can be applied to single expressions as well as a block of Java code<\/a>.<\/span><\/p>\n

As you already know, a block of code in Java is a group of zero or more statements between balanced braces and can be used anywhere a single statement is allowed.<\/span><\/p>\n

 <\/p>\n

The if-then Statement.\u00a0<\/b><\/p>\n

Let’s suppose we only want to execute a block of code under certain circumstances. The if-then statement accomplishes this by allowing our application to execute a particular block of code if and only if during runtime a boolean expression evaluates to true:<\/span><\/p>\n

\"\"<\/p>\n

For example, let’s print “Good Morning” if the hour of the day is less than 11:<\/span><\/p>\n

if (hourOfDay < 11)
\n<\/span><\/i>System.out.println(“Good Morning”);<\/span><\/i><\/p>\n

As you can see from the example, we don’t need curly braces when there is just one statement. We can also, for example, increment some value, <\/span>morningGreetingCount<\/span><\/i>, every time the greeting is printed. We can easily add one more statement to the code block:<\/span><\/p>\n

if (hourOfDay < 11) {
\n<\/span><\/i>System.out.println(“Good Morning”);
\n<\/span><\/i>morningGreetingCount++;
\n<\/span><\/i>}<\/span><\/i><\/p>\n

In this case, we added curly braces.<\/span><\/p>\n

The if-then-else Statement.<\/b><\/p>\n

Let’s imagine that we want to display a different message if it is 11 a.m. or later. We can use for these two if-then statements:<\/span><\/p>\n

if(hourOfDay < 11) {
\n<\/span><\/i>System.out.println(“Good Morning”);
\n<\/span><\/i>}\u00a0<\/span><\/i><\/p>\n

if(hourOfDay >= 11) {
\n<\/span><\/i>System.out.println(“Good Afternoon”);
\n<\/span><\/i>}\u00a0<\/span><\/i><\/p>\n

We are performing an evaluation on <\/span>hourOfDay <\/span><\/i>twice, so this seems redundant. In some cases, the cost of the boolean expression we\u2019re evaluating could be computationally expensive. Fortunately, Java has a more useful approach in the form of an if-then-else statement. <\/span><\/p>\n

\"\"<\/p>\n

Let’s change our code:<\/span><\/p>\n

if(hourOfDay < 11) {
\n<\/span><\/i>System.out.println(“Good Morning”);
\n<\/span><\/i>} else {
\n<\/span><\/i>System.out.println(“Good Afternoon”);
\n<\/span><\/i>}<\/span><\/i>\u00a0<\/span><\/p>\n

Now the boolean evaluation happening only once and our code are truly branching between one of the two possible options. The <\/span>else<\/span><\/i> operator takes a statement or block of statements, in the same way as the if statement does. We can append additional <\/span>if-then <\/span><\/i>statements to an <\/span>else<\/span><\/i> block:<\/span><\/p>\n

if(hourOfDay < 11) {
\n<\/span><\/i>System.out.println(“Good Morning”);
\n<\/span><\/i>} else if(hourOfDay < 15) {
\n<\/span><\/i>System.out.println(“Good Afternoon”);
\n<\/span><\/i>} else {
\n<\/span><\/i>System.out.println(“Good Evening”);
\n<\/span><\/i>}<\/span><\/i><\/p>\n

The execution will continue until it finds an if-then statement that evaluates to <\/span>true<\/span><\/i>. If neither of the first two expressions is <\/span>true<\/span><\/i>, it will execute the else block. Important thing is that in the creation of complex <\/span>if-then-else<\/span><\/i> statements is that order is important. In some cases, we can get the unreachable code.<\/span><\/p>\n

Ternary Operator. Java language has only one conditional ternary operator in Java. Sometimes better to replace <\/span>if-then-else <\/span><\/i>statement with it:<\/span><\/p>\n

<condition> ?\u00a0 <expression1 >: <expression2><\/span><\/i><\/p>\n

The condition is an operand must be a boolean expression, expression1 and expression2 can be any expression that returns a value.<\/span><\/p>\n

Let’s look at two snippets of code that are equal:<\/span><\/p>\n

if-then-else <\/span><\/i>statement:<\/span><\/p>\n

int y = 10;
\n<\/span><\/i>final int x;
\n<\/span><\/i>if(y > 5) {
\n<\/span><\/i>x = 2 * y;
\n<\/span><\/i>} else {
\n<\/span><\/i>x = 3 * y;
\n<\/span><\/i>}\u00a0<\/span><\/i><\/p>\n

Ternary operator:<\/span><\/p>\n

int y = 10;
\n<\/span><\/i>int x = (y > 5) ? (2 * y) : (3 * y);<\/span><\/i><\/p>\n

For better readability, it is better to add parentheses around the expressions in ternary operations, but it is certainly not required.<\/span><\/p>\n

The switch Statement<\/b><\/p>\n

A <\/span>switch<\/span><\/i> statement is a complex decision-making operator that evaluates a single value and flow is redirected to the first matching case statement. If no such case statement is found that matches the value, an optional default statement (if there is one) will be called. Here is syntax of switch-case:<\/span><\/p>\n

\"\"<\/p>\n

The value for a <\/span>case<\/span><\/i> must have the same data type as the variable in the <\/span>switch<\/span><\/i>. The <\/span>case<\/span><\/i> values must be unique, duplications are not allowed.<\/span><\/p>\n

The <\/span>break<\/span><\/i> statement is optional and it is used inside the switch to terminate a statement sequence. In another case, execution will continue on into the next <\/span>case<\/span><\/i>. The <\/span>default<\/span><\/i> can appear anywhere inside the <\/span>switch<\/span><\/i> block and it is optional.<\/span><\/p>\n

From JDK7 we can use a string literal\/constant in <\/span>switch<\/span><\/i> statement. The switch statement on Strings can be more expensive than on primitive data types. Better to use switch for strings only in cases controlling data is already in string form. You need to ensure that the expression in any switch statement is not null to prevent a NullPointerException.<\/span><\/p>\n

The switch statement does a case sensitive comparison. Let’s look at example:<\/span><\/p>\n

String animal = “dog”;
\n<\/span><\/i>switch (animal) {
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0case “dog”:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“Dog is barking”);
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0break;
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0case “cat”:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“Cat is fluffy”);
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0break;
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0case “bear”:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“Bear loves honey”);
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0break;
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0case “mouse”:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“Mouse is small”);
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0break;
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0case “elephant”:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“Elephant is hude”);
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0break;
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0default:
\n<\/span><\/i>\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.out.println(“I don’t know this animal”);
\n<\/span><\/i>}<\/span><\/i><\/p>\n

The current output will be <\/span>“Dog is barking”.<\/span><\/i> If animal variable to <\/span>\u201cbear\u201d <\/span><\/i>the output will be<\/span> \u201cBear loves honey\u201d. <\/span><\/i>If animal equals <\/span>\u201clion\u201d t<\/span><\/i>he default block will be executed and our output will be<\/span> “I don’t know this animal”.<\/span><\/i><\/p>\n

What if we miss all break operators? Answer is easy. All Strings will be printed.<\/span><\/p>\n


\nThe while Statement
\n<\/b>The <\/span>while<\/span><\/i> statement is a\u00a0 repetition control structure, looping statement. This Control Statements in Java executes a part of code (one or more statements) zero or multiple times until the certain termination condition is true. The condition is a boolean expression. Let’s look at the <\/span>while<\/span><\/i> statement structure:<\/span><\/p>\n

\"\"<\/p>\n

The while loop has similarities with the if-then statement. Both are composed of a condition and a block of statements. The condition is evaluated before each iteration of the loop and exits if the evaluation returns false. The statement block may never be executed, because that while loop may terminate after its first evaluation of the boolean expression. Let’s create an example<\/span><\/p>\n

int counter = 5;
\n<\/span><\/i>while (counter > 0) {
\n<\/span><\/i>counter–;
\n<\/span><\/i>System.out.println(counter + \u201c;\u201d);
\n<\/i>}\u00a0<\/span><\/i><\/p>\n

This code will print numbers from 5 to 1, semicolon-separated.
\n<\/span>Consider the following code:\u00a0<\/span><\/p>\n

int x = 2;
\n<\/span><\/i>int y = 5;
\n<\/span><\/i>while(x < 10)
\n<\/span><\/i>y++;\u00a0<\/span><\/i><\/p>\n

The loop will never end! The boolean expression will never be modified and always be true. As you see, we got an infinite loop. <\/span><\/p>\n

The do-while Statement<\/b>
\n<\/span>Java language also allows for the creation of a do-while loop. This type of loop guarantees that the statement or block of statements will be executed at least once.\u00a0 The conditional expression in this type of loop is after the statements. Let’s look at code snippet:<\/span><\/p>\n

int x = 0;
\n<\/span><\/i>do {
\n<\/span><\/i>x++;
\n<\/span><\/i>} while(false);
\n<\/span><\/i>System.out.println(x);<\/span><\/i><\/p>\n

The code statement will be executed even the conditional expression is <\/span>false<\/span><\/i>, and the output of this code will be \u201c1\u201d.<\/span><\/p>\n

The for Statement<\/b>
\n<\/span>The simple <\/span>for<\/span><\/i> loop has the same sections as others that we already discussed, but there are also two new sections: an initialization block and an update statement:<\/span><\/p>\n

\"\"<\/p>\n

For this kind of loop, firstly, the initialization statement is executed, after we check boolean expression. If the condition is true continue, else exit the loop. The body executes and just after this the block of updating the statements is executed.\u00a0<\/span><\/p>\n

Here is an example that prints the numbers 0 to 9: <\/span><\/p>\n

for(int i = 0; i < 10; i++) {
\n<\/span><\/i>System.out.print(i + ” “);
\n<\/span><\/i>}\u00a0<\/span><\/i><\/p>\n

It is also possible to create an infinite loop with this kind of loop:
\n<\/span>for( ; ; ) {
\n<\/span><\/i>\u00a0<\/span><\/i> System.out.println(“Hello World”);
\n}<\/span><\/i><\/p>\n

We can add multiple expressions\/statements in initialization, condition, updating Control Statements in Java blocks<\/span>.<\/span><\/i><\/p>\n

The for-each Statement<\/b>
\n<\/span><\/i>The <\/span>for-each<\/span><\/i> loop specifically designed for iterating over arrays and Collection objects. Its declaration consists of an initialization section and an object to be iterated over. The structure of the <\/span>for-each<\/span><\/i> loop can be found below:<\/span><\/p>\n

\"\"<\/p>\n

An object to be iterated over has to be a built-in Java array or an object whose class implements java.lang.Iterable. On each loop iteration, the variable on the left-hand side of the statement is assigned a new value from the array or collection on the right-hand side of the statement. For example:<\/span><\/p>\n

List<String> listOfNumbers = List.of(“one”, “two”, “three”);<\/span><\/i>
\n<\/span><\/i>for(String number: <\/span><\/i>listOfNumbers<\/span><\/i>) {
\n<\/span><\/i>System.out.print(number + ” “);
\n<\/span><\/i>}<\/span><\/i><\/p>\n

The output for this code will be \u201cone two three\u201d. This code snippet can be replaced with <\/span>for<\/span><\/i> loop:<\/span><\/p>\n

List<String> listOfNumbers = List.of(“one”, “two”, “three”);<\/span><\/i>
\n<\/span><\/i>for(int i=0; i <\u00a0 <\/span><\/i>listOfNumbers.size(); i++) {
\n<\/span><\/i>System.out.print(<\/span><\/i>listOfNumbers.get(i)<\/span><\/i> + ” “);
\n<\/span><\/i>}<\/span><\/i><\/p>\n

As you can compare, the<\/span> for-each<\/span><\/i> loop looks more readable.<\/span><\/p>\n

Nested Loops.<\/b> Loops can contain other loops. The most common example of nested loop is the iteration over a two-dimensional array:<\/span><\/p>\n

int sum = 0;
\n<\/span><\/i>int[][] complexArray = {{1,2,3},{4,5,6},{7,8,9}};
\n<\/span><\/i>for(int[] simpleArray : complexArray) {
\n<\/span><\/i>\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0for(int i=0; i < simpleArray.length; i++) {
\n<\/span><\/i>\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 sum += simpleArray[i];
\n<\/span><\/i>\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 }
\n<\/span><\/i>\u00a0 \u00a0 \u00a0}
\n<\/span><\/i>\u00a0 System.out.println(sum);<\/span><\/i><\/p>\n

As the output of this code, you will get printed the sum of all elements of the two-dimensional matrix. In this code\u00a0 <\/span>for<\/span><\/i> loop and <\/span>for-each<\/span><\/i> loop are intentionally mixed, it is not convenient. I just\u00a0 wanted to show that the same logic can be written in many ways.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

You are already familiar with the term statement, which can simply be defined as an instruction given to the computer to perform specific operations. Control Statements in Java are controlling program flow and determining whether the other statements will be executed or not. Java statement is a complete unit of execution, terminated with a semicolon. […]<\/p>\n","protected":false},"author":1,"featured_media":2168,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42],"tags":[407,415,416,417,411,412,418,413,414],"class_list":["post-2124","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorials","tag-control-statements","tag-do-while","tag-for","tag-for-each","tag-if-then","tag-if-then-else","tag-nested-loops","tag-switch","tag-while"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2124","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=2124"}],"version-history":[{"count":0,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2124\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/2168"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=2124"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=2124"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=2124"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}