How does Java’s ‘for each’ loop operate in detail?

Introduction to the ‘for each’ Loop in Java

Brief Overview of the Traditional for Loop

The traditional for loop is a control flow statement in Java that allows you to iterate over a range of values or elements. It’s a flexible loop that consists of three main parts: initialization, condition, and increment/decrement. Here’s the basic syntax:

for (initialization; condition; increment/decrement) {
    // Code to be executed
}

Initialization: This is where you declare and initialize your loop control variable. It runs only once at the beginning of the loop.
Condition: This is a boolean expression evaluated before each iteration. If the condition is true, the loop continues; if false, the loop terminates.
Increment/Decrement: This part updates the loop control variable, usually incrementing or decrementing it after each iteration.

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

In this example, the loop will print numbers from 0 to 4. The for loop is highly versatile and can be used for various iteration tasks, such as iterating over arrays, lists, or even custom ranges.

However, this flexibility comes with some drawbacks. The traditional for loop requires you to manage the loop control variable and ensure the loop bounds are correctly set. Mistakes can lead to issues like infinite loops or index out-of-bounds errors.

Introduction to the Enhanced for Loop (for-each Loop)

To simplify iteration, especially over collections and arrays, Java introduced the enhanced for loop, commonly known as the for-each loop, starting with Java 5. The for-each loop is designed to iterate over elements in a collection or array without needing explicit management of the loop control variable or loop bounds.

Syntax:

for (Type element : collection) {
    // Code to be executed
}

Type: The data type of the elements in the collection or array.
element: A variable that represents each element of the collection during each iteration.
collection: The array or collection you are iterating over.

Example:

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

In this example, the for-each loop iterates over each element in the numbers array and prints it. The loop automatically handles the iteration, making the code cleaner and reducing the risk of errors.

The for-each loop is particularly useful when you need to process each element in a collection or array sequentially, and you don’t need to modify the collection or know the current index. It provides a more readable and concise way to iterate, especially for beginners or in scenarios where you don’t need the extra control offered by the traditional for loop.

Fundamental Syntax

The ‘for each’ loop in Java, also known as the enhanced for loop, is a convenient way to iterate over elements of an array or a collection. It simplifies the process of looping through data structures by eliminating the need for an explicit counter or index.

Structure of a ‘for each’ Loop

The basic syntax of a ‘for each’ loop is as follows:

for (Type element : collection) {
    // Code to be executed for each element
}

Type: The data type of the elements in the array or collection.
element: A variable that holds the current element in each iteration.
collection: The array or collection to iterate over.

Example with an Array

Let’s say we have an array of integers, and we want to print each element:

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {
    System.out.println(number);
}

In this example:

• int is the data type of the elements in the numbers array.
• number is the variable that holds the current element during each iteration.
• The loop will iterate over each element in the numbers array and print i

Example with a Collection

Now, consider a List of strings. Here’s how you can use a ‘for each’ loop to iterate through it:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {
    System.out.println(name);
}

In this example:

• String is the data type of the elements in the names list.
• name is the variable that holds the current element during each iteration.
• The loop will iterate over each element in the names list and print it.

How the ‘for each’ Loop Works

Detailed Explanation of How the Loop Iterates Over Elements

The ‘for each’ loop in Java is designed to iterate over elements in a collection or array in a streamlined manner. Here’s how it works internally:

1. Initialization: The loop starts by initializing a variable (defined in the loop declaration) to hold each element of the collection or array, one at a time.
2. Iteration: The loop then automatically iterates over each element in the collection or array. During each iteration, the current element is assigned to the loop variable.
3. Execution: The code block inside the loop is executed for each element. After executing the block, the loop moves to the next element in the collection or array.
4. Completion: Once all elements have been processed, the loop terminates.

Here’s an example to illustrate this:

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {
    System.out.println(number);
}

• The loop initializes number to the first element of the array (1), prints it, and then proceeds to the next element (2), and so on until all elements are processed.

Differences Between a ‘for each’ Loop and a Traditional for Loop

The ‘for each’ loop is often contrasted with the traditional for loop. Here’s how they differ:

1. Syntax:
   • Traditional for Loop:

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

‘for each’ Loop

for (int number : numbers) {
    System.out.println(number);
}

1. Index Management:
   • In a traditional for loop, you manually manage the index (i in the example) and use it to access elements. This involves more code and a higher chance of errors, such as off-by-one errors.
   • In a ‘for each’ loop, index management is handled automatically, making the code cleaner and reducing the likelihood of mistakes.
2. Flexibility:
   • The traditional for loop offers more flexibility, allowing you to skip elements, iterate in reverse, or modify the collection during iteration.
   • The ‘for each’ loop is more straightforward but does not provide direct access to the index or allow modifications to the collection during iteration.

Explanation of Enhanced Readability and Reduced Potential for Errors

The ‘for each’ loop enhances readability and reduces potential for errors in several ways:

1. Simplified Syntax: The syntax of the ‘for each’ loop is more concise and easier to understand, especially for beginners or when reviewing code.
2. No Indexing Issues: Since there’s no need to manage an index, the risk of common errors (like off-by-one errors or incorrect array bounds) is minimized.
3. Clear Intent: The ‘for each’ loop clearly expresses the intent to iterate over all elements in a collection or array, making the code more intuitive.
4. Reduced Boilerplate Code: By eliminating the need for index initialization, condition checks, and incrementing, the ‘for each’ loop reduces boilerplate code, making the loop easier to write and maintain.

Overall, the ‘for each’ loop is a powerful tool for iterating over collections and arrays in Java, offering a balance of simplicity and safety, particularly in scenarios where you simply need to process every element without modifying the underlying collection.

Iterable Interface

How the ‘for each’ Loop Relies on the Iterable Interface

The ‘for each’ loop in Java is designed to work seamlessly with any object that implements the Iterable interface. The Iterable interface is a part of the Java Collections Framework and serves as the foundation for the ‘for each’ loop’s functionality.

When you use a ‘for each’ loop, the loop internally relies on the Iterable interface to iterate over the elements of a collection. This interface ensures that the object being iterated over provides a mechanism to sequentially access each element, one by one.

public interface Iterable<T> {
    Iterator<T> iterator();
}

• T is the type of elements returned by the iterator.

Any class that implements Iterable must provide an implementation of the iterator() method, which returns an Iterator object.

Explanation of the iterator() Method and How It Is Implicitly Used

The iterator() method is crucial for the functioning of the ‘for each’ loop. Here’s how it works:

1.iterator() Method:

• The iterator() method is called on the collection (or any object implementing Iterable) when the ‘for each’ loop begins.
• This method returns an Iterator object, which is used to traverse the collection.

2.Iterator Object:

• The Iterator object provides two key methods:
  • hasNext(): Returns true if there are more elements to iterate over.
  • next(): Returns the next element in the iteration.

3.Implicit Usage in ‘for each’ Loop:

• When you write a ‘for each’ loop, you don’t explicitly see the ”iterator()” method being called or the Iterator object being used. However, behind the scenes, Java uses these to control the loop.
• The loop repeatedly calls ”hasNext()” to check if more elements are available. If ”hasNext()” returns true, the loop calls ”next()” to retrieve the next element and assigns it to the loop variable.

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {
    System.out.println(name);
}

This loop internally works as if you wrote:

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    System.out.println(name);
}

Discussion on How Custom Classes Can Be Made Iterable

To make a custom class iterable, you need to implement the Iterable interface and provide an implementation for the iterator() method. Here’s how you can do it:

1. Implementing Iterable:
   • Your custom class should implement Iterable<T>, where T is the type of elements you want to iterate over.
2. Creating an Iterator:
   • Inside the iterator() method, you need to return an Iterator object that can iterate over the elements of your class.

Example:

Suppose you have a custom class MyCollection that stores an array of integers:

import java.util.Iterator;

public class MyCollection implements Iterable<Integer> {
    private int[] data;

    public MyCollection(int[] data) {
        this.data = data;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < data.length;
            }

            @Override
            public Integer next() {
                return data[index++];
            }
        };
    }
}

Now you can use a ‘for each’ loop with MyCollection:

MyCollection collection = new MyCollection(new int[]{1, 2, 3, 4, 5});

for (int num : collection) {
    System.out.println(num);
}

Limitations of the ‘for each’ Loop

While the ‘for each’ loop in Java is a powerful and convenient tool for iterating over elements in arrays and collections, it does have some limitations. Understanding these limitations is crucial for making informed decisions about when to use it.

1. Cannot Modify the Collection Directly During Iteration

One significant limitation of the ‘for each’ loop is that you cannot modify the collection while iterating over it. This includes adding, removing, or updating elements in the collection. Attempting to do so can lead to unexpected behavior or runtime exceptions.

Example:

List<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));

for (String name : names) {
    if (name.equals("Bob")) {
        names.remove(name); // This will throw ConcurrentModificationException
    }
}

Explanation:

• The ConcurrentModificationException is thrown because modifying the collection directly while iterating over it is not allowed. The ‘for each’ loop relies on an iterator, which does not expect the collection to change during iteration.

Workaround:

• To safely modify a collection while iterating, you can use an Iterator explicitly and its remove() method, or collect changes in a separate list and apply them after iteration.

Example Using Iterator:

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("Bob")) {
        iterator.remove(); // Safe way to remove elements
    }
}

2. Inability to Access the Index of the Current Element

The ‘for each’ loop does not provide direct access to the index of the current element. This limitation can be problematic if you need to know the position of an element within the collection or array.

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {
    // Cannot determine the index of 'name'
}

Workaround:

• To access the index, you can use a traditional for loop or maintain a separate counter.

Example Using Traditional for Loop:

for (int i = 0; i < names.size(); i++) {
    String name = names.get(i);
    System.out.println("Index: " + i + ", Name: " + name);
}

Example Using Counter:

int index = 0;
for (String name : names) {
    System.out.println("Index: " + index + ", Name: " + name);
    index++;
}

3. Not Suitable for Iterating Over Multiple Collections Simultaneously

The ‘for each’ loop is designed to iterate over a single collection or array at a time. It is not suited for scenarios where you need to iterate over multiple collections simultaneously.

Example:

List<String> names1 = Arrays.asList("Alice", "Bob", "Charlie");
List<Integer> ages = Arrays.asList(25, 30, 35);

// Cannot directly iterate over both lists simultaneously with 'for each' loop

1. Impact on Performance Compared to Other Loop Structures

a. Memory and CPU Usage:
‘For Each’ Loop:

Generally speaking, the ‘for each’ loop is optimized for readability and ease of use, not for raw performance.

for (int i = 0; i < names1.size(); i++) {
    String name = names1.get(i);
    int age = ages.get(i);
    System.out.println("Name: " + name + ", Age: " + age);
}

Example Using Iterators:

Iterator<String> namesIterator = names1.iterator();
Iterator<Integer> agesIterator = ages.iterator();

while (namesIterator.hasNext() && agesIterator.hasNext()) {
    String name = namesIterator.next();
    int age = agesIterator.next();
    System.out.println("Name: " + name + ", Age: " + age);
}

Practical Examples of the ‘For Each’ Loop in Java

1. Example with Arrays

The ‘for each’ loop is commonly used with arrays to iterate through elements of different data types, including both primitive types and objects.

Example with a Primitive Type Array:

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {
    System.out.println(number);
}

In this example:

• The ‘for each’ loop iterates through the numbers array, printing each integer.

Example with an Object Array:

String[] fruits = {"Apple", "Banana", "Cherry"};

for (String fruit : fruits) {
    System.out.println(fruit);
}

In this example:

• The ‘for each’ loop iterates over the fruits array of String objects and prints each fruit name.

2. Example with Lists

The ‘for each’ loop can also be used to iterate over elements in a List, which is part of the Java Collections Framework.

Example with a List of Integers:

List<Integer> numbers = Arrays.asList(10, 20, 30, 40);

for (int number : numbers) {
    System.out.println(number);
}

In this example:

• The loop iterates over each element in the List of integers and prints it.

Example with a List of Objects:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {
    System.out.println(name);
}

In this example:

• The ‘for each’ loop iterates through a List of String objects and prints each name.

3. Example with Sets

Sets, like lists, can also be iterated using the ‘for each’ loop. Since sets do not allow duplicate elements and do not maintain order, the order of iteration may not be predictable.

Example with a Set of Integers:

Set<Integer> uniqueNumbers = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));

for (int number : uniqueNumbers) {
    System.out.println(number);
}

In this example:

• The loop iterates through a Set of integers, printing each unique element.

4. Example with Maps

The ‘for each’ loop can be used with a Map, but since maps contain key-value pairs, you’ll typically iterate over the entrySet() to access both keys and values.

Example with a Map (Iterating Over Entry Set):

Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
ageMap.put("Charlie", 35);

for (Map.Entry<String, Integer> entry : ageMap.entrySet()) {
    System.out.println("Name: " + entry.getKey() + ", Age: " + entry.getValue());
}

In this example:

• The loop iterates over the entrySet() of the map, which contains the key-value pairs, and prints both the name and the age.

5. Using the ‘For Each’ Loop with Different Data Types

The ‘for each’ loop is versatile and can be used with a wide range of data types:

• Primitives (e.g., int, double, char): Easily handled with basic arrays or collections of these types.
• Objects (e.g., String, UserDefinedClass): The loop handles objects just as easily, making it a useful tool for iterating over complex data structures.

Example with Primitive Type (double):

double[] temperatures = {98.6, 99.1, 97.8};

for (double temp : temperatures) {
    System.out.println(temp);
}

Example with Object Type (Custom Class):

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

List<Person> people = Arrays.asList(new Person("Alice", 25), new Person("Bob", 30));

for (Person person : people) {
    System.out.println("Name: " + person.name + ", Age: " + person.age);
}

In this example:

• The ‘for each’ loop iterates over a list of Person objects and prints the details of each.

6. Nested ‘For Each’ Loops for Multidimensional Arrays or Collections of Collections

In scenarios where you have multidimensional arrays or collections within collections (e.g., a list of lists), you can nest ‘for each’ loops to access individual elements.

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int[] row : matrix) {
    for (int number : row) {
        System.out.print(number + " ");
    }
    System.out.println();
}

In this example:

• The outer loop iterates over each row (an array), while the inner loop iterates over each element in that row, printing the matrix.

Example with a List of Lists:

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("Apple", "Banana"),
    Arrays.asList("Carrot", "Daikon"),
    Arrays.asList("Eggplant", "Fig")
);

for (List<String> list : listOfLists) {
    for (String item : list) {
        System.out.println(item);
    }
}

In this example:

• The outer ‘for each’ loop iterates over each list within the List, and the inner loop iterates over the items in each individual list.

‘For Each’ Loop vs. Stream API in Java

Java offers multiple ways to iterate over collections and arrays, with the ‘for each’ loop and the Stream API being two popular choices. While both can be used for similar purposes, they have different strengths and are suited to different scenarios.

1. Comparison Between ‘For Each’ Loop and Java Streams

a. Syntax and Usage:

• ‘For Each’ Loop:
  • The ‘for each’ loop is simple and straightforward, primarily used for iterating over elements in a collection or array.
  • Syntax: for (Type element : collection) { /* use element */ }

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
for (String name : names) {
    System.out.println(name);
}

Stream API:

• The Stream API, introduced in Java 8, is a more powerful tool that supports functional-style operations on streams of elements, such as filtering, mapping, and reducing.
• Syntax: collection.stream().operation().forEach(...)

Example:

names.stream().forEach(name -> System.out.println(name));

c. Performance:

• ‘For Each’ Loop:
  • Generally has lower overhead for simple iterations.
  • Suitable for small to medium-sized collections where operations are straightforward.
• Stream API:
  • Streams introduce some overhead due to their functional nature, but this can be mitigated by parallel processing.
  • Better suited for large collections where complex operations are required, and parallel streams can be used to enhance performance.

2. When to Prefer Streams Over ‘For Each’ and Vice Versa

a. When to Prefer the ‘For Each’ Loop:

• Simplicity:
  • When you need a straightforward loop to iterate over elements without additional processing.
  • Example: Printing elements, simple transformations, or operations where the index is required.
• State Management:
  • When you need to maintain or update a state across iterations (e.g., counters, flags).
  • Example: Summing values while checking conditions in a loop.

• Readability:
  • For developers unfamiliar with functional programming concepts, the ‘for each’ loop is often easier to read and understand.

b. When to Prefer the Stream API:

• Complex Operations:
  • When performing multiple transformations or operations like filtering, mapping, and reducing.
  • Example: Filtering a list of objects and transforming the result into a new list.
• Conciseness:
  • When you want to write concise, functional-style code that is easy to maintain.
  • Example: Combining operations like filtering and mapping in a single statement.

• Parallel Processing:
  • When working with large datasets where parallel processing can significantly improve performance.
  • Example: Processing a large collection in parallel to reduce execution time.

3. Example Comparison

a. Filtering and Printing with ‘For Each’ Loop:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Dave");

for (String name : names) {
    if (name.startsWith("A")) {
        System.out.println(name);
    }
}

• Simple filtering and printing with a ‘for each’ loop.

b. Filtering and Printing with Stream API:

names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

The same operation using Stream API is more concise and functional.

Common Use Cases for ‘For Each’ Loop

The ‘for each’ loop is widely used in various real-world scenarios to iterate over collections and arrays. Understanding its common use cases and best practices helps in writing effective and maintainable code.

1. Iterating Over Collections in Real-World Scenarios

a. Processing User Input:

When you need to process a list of user inputs or actions, such as displaying user data or performing operations on user-generated content.

Example: Displaying User Names:

List<String> userNames = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : userNames) {
    System.out.println("User: " + name);
}

b. Generating Reports:

When generating reports or summaries from a collection of data, such as sales records, transactions, or inventory items.

Example: Calculating Total Sales:

List<Double> sales = Arrays.asList(100.50, 200.75, 50.25);

double totalSales = 0;
for (double sale : sales) {
    totalSales += sale;
}
System.out.println("Total Sales: " + totalSales);

c. Performing Batch Operations:

When performing batch operations like updating or deleting items in a collection.

Example: Updating Prices:

List<Double> prices = Arrays.asList(10.99, 20.50, 30.00);

for (int i = 0; i < prices.size(); i++) {
    prices.set(i, prices.get(i) * 1.10); // Increase each price by 10%
}

d. Filtering and Processing Data:

When filtering and processing data to extract relevant information or perform specific actions based on certain criteria.

Example: Finding Even Numbers:

int[] numbers = {1, 2, 3, 4, 5, 6};

for (int number : numbers) {
    if (number % 2 == 0) {
        System.out.println(number + " is even");
    }
}

e. Configuring or Initializing Objects:

When configuring or initializing objects based on a set of parameters or data from a collection.

Example: Initializing User Objects:

List<String> userNames = Arrays.asList("Alice", "Bob", "Charlie");
List<User> users = new ArrayList<>();

for (String name : userNames) {
    users.add(new User(name));
}

2. Best Practices for Using ‘For Each’ Loops in Code

a. Avoid Modifying the Collection During Iteration:

Do not modify the collection (e.g., adding or removing elements) while iterating over it with a ‘for each’ loop. This can lead to ConcurrentModificationException or unexpected behavior.

Correct Approach:

• Use an Iterator for safe removal of elements.

Example:

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.startsWith("A")) {
        iterator.remove(); // Safe removal
    }
}

b. Use Descriptive Variable Names:

Use descriptive names for loop variables to make your code more readable and maintainable.

Example:

for (String itemName : itemNames) {
    System.out.println("Item: " + itemName);
}

c. Avoid Complex Logic Inside the Loop:

Keep the logic inside the loop simple to maintain readability. Complex operations should be handled outside or by using helper methods.

Example:

Less Readable:

for (String name : names) {
    if (name.length() > 5) {
        String upperName = name.toUpperCase();
        System.out.println(upperName);
    }
}

More Readable:

for (String name : names) {
    if (name.length() > 5) {
        printUpperCase(name);
    }
}

private void printUpperCase(String name) {
    System.out.println(name.toUpperCase());
}

d. Use Enhanced For Loops for Collections and Arrays:

The ‘for each’ loop is well-suited for iterating over collections and arrays. Use it when you don’t need access to indices or when you’re not modifying the collection.

Example:

String[] colors = {"Red", "Green", "Blue"};

for (String color : colors) {
    System.out.println("Color: " + color);
}

e. Consider Performance for Large Data Sets:

Example:

List<Integer> largeList = generateLargeList();
largeList.stream().parallel().forEach(System.out::println);

f. Avoid Using Indices When Not Needed:

If you don’t need the index of the current element, avoid using the traditional for loop with indices. Use ‘for each’ loops to keep the code clean.

Example:

Less Preferred:

for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

Preferred:

for (String name : names) {
    System.out.println(name);
}

Performance Considerations for the ‘For Each’ Loop in Java

When choosing a loop structure in Java, performance can be a key consideration, especially in applications that process large datasets or require high efficiency. The ‘for each’ loop, while convenient and readable, has specific performance characteristics that may make it more or less suitable depending on the situation.

1. Impact on Performance Compared to Other Loop Structures

a. Memory and CPU Usage:

• ‘For Each’ Loop:
  • The ‘for each’ loop is generally optimized for readability and ease of use rather than raw performance.
  • For arrays and lists, the ‘for each’ loop offers performance comparable to the traditional for loop because it directly accesses elements without additional overhead.
  • For other collections like Set or Map, the ‘for each’ loop may introduce some overhead because it relies on the underlying Iterator, which might involve more complex operations than simple array indexing.
• Traditional for Loop:
  • A traditional for loop provides more control over iteration, particularly when accessing elements by index.
  • It may offer better performance when iterating over large arrays or ArrayList because it avoids the overhead associated with the Iterator used in the ‘for each’ loop.

Example:

for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

Stream API:

• Streams can be more resource-intensive than ‘for each’ loops due to the creation of additional objects and the overhead of functional operations.
• However, the Stream API can be optimized with parallel streams for certain use cases, potentially offering better performance for large datasets.
• Example:

array.stream().forEach(System.out::println);

b. Parallel Processing:

• ‘For Each’ Loop:
  • The ‘for each’ loop processes elements sequentially, making it less suitable for tasks where parallel processing could significantly speed up execution.

Example:

for (int number : numbers) {
    process(number); // Sequential processing
}

Parallel Streams:

Example:

numbers.parallelStream().forEach(number -> process(number)); // Parallel processing

2. Situations Where ‘For Each’ Might Not Be the Best Choice

a. When Index Access is Required:

• The ‘for each’ loop does not provide access to the index of the current element, making it unsuitable when you need to know the position of the element in the collection.
• Alternative: Use a traditional for loop with an index variable.

Example:

for (int i = 0; i < array.length; i++) {
    if (i == targetIndex) {
        System.out.println(array[i]);
    }
}

b. When Modifying the Collection During Iteration:

• Modifying a collection (e.g., adding or removing elements) during iteration with a ‘for each’ loop can lead to ConcurrentModificationException.
• Alternative: Use an Iterator or traditional for loop with careful management of indices.

Example with Iterator:

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    if (conditionMet(iterator.next())) {
        iterator.remove(); // Safe removal
    }
}

c. Highly Performance-Critical Parts:

In highly performance-critical parts, especially for datasets that are really large, the ‘for each’ loop overhead is considerable because of its implicit use of an iterator.
Alternatively, when the situation allows, one can use a traditional for-each loop or parallel streams.

Example with traditional for loop

for (int i = 0; i < largeArray.length; i++) {
    process(largeArray[i]);
}

d. When There is a Requirement for Custom Control Flow:

In those cases, when custom control flow is needed, such as iterating in reverse, skipping elements, or iterating with a step value other than 1, the ‘for each’ loop is never flexible enough.
Alternative: Use traditional for loop or while loop.

Example for reverse iteration

for (int i = array.length - 1; i >= 0; i--) {
    System.out.println(array[i]);
}

Overview
The Java enhanced ‘for’ loop is very helpful if some simple, straightforward iterations over collections and arrays are performed. However, it is not the best choice for the items below because it cannot:

Access or modify the collection.

Do high performance-critical operations on big data.

Customize iteration control such as iterate in reverse, with skips.

Take advantage of parallelism to optimize performance.
In these cases, performance or flexibility might be better catered for with the traditional for loops, Iterator, or the Stream API. The ability to grasp such subtleties will help make the right choices for the required loop structure in terms of balancing readability with performance and functionality.