For Loop Program in Java
The for-loop program in Java is written when we want a particular set of statements to be executed repeatedly until the given criteria/ condition is met. The general syntax of the for-loop is:
Initialization: This block serves the purpose of initializing the variables. The initialization part is executed at the beginning and only once. The initialized value will be changed after each iteration.
Condition: After the initialization, the control comes to the condition. The life of a for-loop depends on the condition. The for-loop will be executed till the condition evaluates true. All the statements written in the condition part must be of the Boolean nature. The condition is evaluated before the control shifts to the body of a for-loop.
Decrement/ Increment: This portion of a for-loop is optional. We can even shove the statements written in this portion inside the body of the for-loop. The part of the for-loop is executed after the body of the loop is executed.
Body: The control will only reach the body part when the condition is evaluated true. Different types of work are done in this part of the loop, like calling a method, doing some arithmetic operation, printing sentences on the console, etc.
The curly braces ({}) are only mandatory when there is more than one statement in the body of the for loop. For only one statement, one may or may not drop these curly braces. Let’s understand the working of Java for loop through a Java program.
Filename: ForLoopExample.java
Output:
Explanation: Observe there is only one statement; therefore, we have easily omitted the curly braces ({}). In the for-loop, we have:
Initialization: In our case, we are initializing a variable i to 0. Hence, the iteration begins from 0.
Condition: In the above program, we have checked the condition i < 10. This means the loop will be executed till the variable i is less than 10. The default value of the condition is true, i.e., if we specify nothing in the condition part, the compiler will assume the condition is true.
Increment/ Decrement: In our case, we have used increment. After each iteration, the value of i is incremented by 1. It increases the value until the condition does not results false.
Let’s talk about iterations.
Iteration1: In the first iteration, the first step will be to execute the initialization expression. We have int i = 0; Thus, the variable i will get the value 0, and then the control shifts to the condition where we encounter i < 10, i.e., 0 < 10, which evaluates to true. The control goes to the body of the loop and prints the statement on the console. Finally, the increment/ decrement statement is evaluated, which is i++. After the increment operation, the variable i gets incremented from 0 to 1.
Iteration2: In the second iteration, the control moves to the condition expression i < 10, i.e., 1 < 10, which is again true. The control goes to the body of the loop and prints the statement on the console. Finally, the increment operation updates the variable i from 1 to 2.
Similarly, we can explain other iterations too. At last, the variable i will be 10, and the condition 10 < 10 becomes false, and the loop will terminate. Thus, there will be 10 iterations in the above-written for-loop.
Another Way to Write Java for Loop
We have already discussed that increment/ decrement statements are optional and can be shoved in the body of the loop. Thus, we can re-write the above code as:
Filename: ForLoopExample1.java
Output:
Explanation: Observe that, we have more than one statement inside the body of the loop. Therefore, curly braces are mandatory this time. The only difference in the code is the increment expression is not written immediately after the condition. It is inside the body. However, logically speaking, nothing has changed as we are incrementing i only by 1. Hence, the iteration will be 10 times, and output will also remain the same.
Infinite for Loop
The above program can also be written as follows if we want to execute it infinite times.
Filename: ForLoopExample2.java
Output:
Explanation: We already know that the life of a for-loop depends on the condition. In the above program, we have specifically mentioned the condition true. Hence, the condition is true, always resulting in infinite iterations. The increment and initialization expressions are doing nothing at all. Therefore, we can easily drop them. Also, we can drop the keyword true, mentioned in the condition. This is because when we mention nothing in the condition, it is evaluated as true by the Java compiler. Thus, the above program can be re-written as:
Filename: ForLoopExample3.java
Output:
Java for-each loop is the advanced version of Java for-loop. Java for-each loop was introduced in J2SE 5.0. It is mainly used to iterate over arrays or lists. The main advantages of the for-each loop are that it makes code less verbose and is less prone to bug. However, the control we have over the normal for-loop is absent in the case of a for-each loop. For example, we can traverse an array in reverse order using a for-loop but cannot do so using a for-each loop. Also, a for-each loop iterates over each element of the array. It can not skip elements. But we can skip elements using a normal for-loop. In spite of these disadvantages, it is still advised to use a for-each loop. This is because the for-each loop is easy to understand and less wordy.
The following example illustrates the working of the for-each loop.
Filename: ForLoopExample4.java
Output:
Explanation: The variable i is iterating over each and every element of the input array. Therefore, the data type of the variable i must match with the data type of the input array elements; otherwise, the compiler will punish by giving the compilation error.
Let’s learn how we can use a for-each loop in lists.
Filename: ForLoopExample5.java
Output:
Explanation: Notice how easily we can traverse a list using the for-each loop. Had it been a normal for-loop, we would have to use the get() method to access the value from the list at a particular index. Also, there would be a risk of getting an exception like IndexOutOfBoundsException in case of normal for-loop. See the following code.
Filename: ForLoopExample6.java
Output:
Exception in thread “main” java.lang.IndexOutOfBoundsException: Index 9 out of bounds for length 9
at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64)
at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:70)
at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:248)
at java.base/java.util.Objects.checkIndex(Objects.java:372)
at java.base/java.util.ArrayList.get(ArrayList.java:458)
at ForLoopExample6.main(ForLoopExample6.java:20)
Therefore, care must be taken while working with normal for-loop. We never get such exceptions while working with the for-each loop. This is because the for-each loop does not use an index to access the value.