Difference Between for loop and for-each Loop in Java

One of the most popular programming languages, Java, provides a range of tools and methods for iterating over data sets. The classic for loop and the improved for-each loop, also referred to as the "for-each" loop, are two loop structures that are frequently used for this purpose. In this section, we will discuss the differences between for loop and for-each loop.

Java for Loop

One well-known method of iterating over an array or a collection of data in Java is the classic for loop. It gives you precise control over the iteration process by letting you directly define the condition, update, and initialization statements.

We may have total control over the iteration process when using the conventional for loop. You may change the loop variable, add custom logic to the loop body, and even end the loop when a certain condition is satisfied. The for loop is a better choice when working with collections that need to know the elemental index (such as an ArrayList).

To access elements, you can utilize the loop variable as an index. The for loop is sometimes a better option when performing more sophisticated iteration logic that requires nested loops or when we need to iterate over several arrays.

Syntax:

for (initialization; condition; updation) {
    //  for loop body
}

Let's look at some examples to understand how the traditional for loop works:

Example 1: Iterating Over an Array

ForLoopArrayExample.java

public class ForLoopArrayExample {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        for (int r = 0; r < nums.length; r++) {
            System.out.println(nums[r]);
        }
    }
}

Output:

In this example, we traverse through an integer array and output each entry using a standard for loop. The loop structure has explicit definitions for the condition (i < numbers.length), update (i++), and initialization (int i = 0) statements.

Example 2: Iterating Over a List

ForLoopListExample.java

import java.util.Arrays;
import java.util.List;
public class ForLoopListExample {
    public static void main(String[] args) {
        List<String> fruit = Arrays.asList("apple", "banana", "cherry");
        for (int i = 0; i < fruit.size(); i++) {
            System.out.println(fruit.get(i));
        }
    }
}

Output:

apple
banana
cherry

Explanation

The above code shows how to use a classic for loop to traverse over a list. The loop control structure's three components are nonetheless comparable to those in the array example.

Java for-each Loop

Introduced in Java 5, the extended for-each loop streamlines the iteration process over collections, resulting in more understandable and succinct code. When we do not need to update the loop variable or maintain track of the current index, it is especially helpful. The improved for-each loop is preferred due to its readable nature and ease of use.

It is especially helpful when you only want to operate on each element and don't need to access the elements' index. It is possible to iterate across collections like arrays, lists, sets, and maps using the extended for-each loop. Any class that implements the Iterable interface can use it.

The extended for-each loop does not handle concurrent alterations gracefully, thus use caution when iterating over collections that may be updated concurrently (for example, in a multi-threaded environment). In certain situations, we might wish to employ synchronization techniques or an explicit iterator.

The loop variable in an improved for-each loop is essentially final and cannot be changed. It indicates that we are unable to modify the collection's items directly within the loop. Since we do not have direct access to the index, it might be difficult to determine which element generated the exception if loop body throws one.

Syntax:

for (element_type element: collection) {
    // body of for-each loop
}

Let's explore how the enhanced for-each loop works with some examples:

Example 1: Iterating Over an Array

ForEachArrayExample.java

public class ForEachArrayExample {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        for (int num: nums) {
            System.out.println(num);
        }
    }
}

Output:

Explanation

In this example, we cycle through an integer array using an improved for-each loop. Each element is immediately assigned to the num variable by the loop, doing away with the need for update statements and index variables.

Example 2: Iterating Over a List

ForEachListExample.java

import java.util.Arrays;
import java.util.List;
public class ForEachListExample {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "cherry");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Output:

apple
banana
cherry

Explanation

This little piece of code illustrates how easy it is to iterate over a list using the extended for-each loop. The current element in the collection is directly represented by the loop variable fruit.

Distinctions Between for-each and for-loops

Aspect	For Loop	for-each Loop
Control Over Iteration	With initialization, condition, and update statements, it offers clear control.	It provides index or update statement hiding while allowing for automated iteration across the collection components.
Applicability	Fit for situations requiring exact control or modification throughout the iteration process.	Perfect for straightforward iterations requiring simple element access and no intricate reasoning.
Exception Handling	Enables the loop body to handle exceptions in a more sophisticated manner.	for-each simplifies exception handling because index values are not easily accessible.
Readability	Generally, produces, more complex, legible, and succinct code.	Generally, produces simpler, more legible, and succinct code.

Conclusion

Both the improved for-each loop and the conventional for loop are useful tools for Java developers and offer advantages. Which one we choose will rely on your code's particular requirements. The classic for loop is the best option if we want fine-grained control over iteration or more intricate tasks. However, the improved for-each loop is a preferable option if you're only iterating over collections and want clearer, more succinct code.

In actuality, a lot of developers prefer to use the improved for-each loop whenever feasible since it frequently results in more understandable and beautiful code, saving the classic for loop for situations where more precise control is required.

Next TopicDifference Between Fork/Join Framework and ExecutorService in Java

← prev next →