Enhanced for Loop in Java Explained — Syntax, Use Cases and Pitfalls

package io.thecodeforge;

public class RegularVsEnhanced {
    public static void main(String[] args) {

        String[] studentNames = {"Alice", "Bob", "Charlie", "Diana"};

        // --- Old way: regular for loop ---
        // You must manage the index 'i' yourself.
        // Three things to get right: start, condition, increment.
        System.out.println("=== Regular for loop ===");
        for (int i = 0; i < studentNames.length; i++) {
            // Access each element by its position (index)
            System.out.println("Student: " + studentNames[i]);
        }

        System.out.println();

        // --- New way: enhanced for loop ---
        // No index. No length check. No increment.
        // Java handles all of that. You just get each element directly.
        System.out.println("=== Enhanced for loop ===");
        for (String name : studentNames) {
            // 'name' is a fresh copy of each element on every iteration
            System.out.println("Student: " + name);
        }
    }
}

package io.thecodeforge;

public class EnhancedForSyntaxDemo {
    public static void main(String[] args) {

        // --- Example 1: Array of integers ---
        int[] dailyStepCounts = {8432, 11200, 7654, 9988, 6100};

        int totalSteps = 0;

        //  for ( TYPE  VARIABLE : ARRAY_OR_COLLECTION )
        //         |       |             |
        //        int  stepCount   dailyStepCounts
        //
        // Read as: "for each int called stepCount IN dailyStepCounts"
        for (int stepCount : dailyStepCounts) {
            totalSteps += stepCount; // add this day's steps to the running total
        }

        System.out.println("Total steps this week: " + totalSteps);
        System.out.println("Daily average: " + (totalSteps / dailyStepCounts.length));

        System.out.println();

        // --- Example 2: Array of doubles ---
        double[] productPrices = {19.99, 4.50, 149.00, 32.75};

        System.out.println("Price list:");
        for (double price : productPrices) {
            // Format each price to 2 decimal places for clean output
            System.out.printf("  $%.2f%n", price);
        }

        System.out.println();

        // --- Example 3: Array of booleans ---
        boolean[] seatAvailability = {true, false, true, true, false};
        int availableSeats = 0;

        for (boolean isAvailable : seatAvailability) {
            if (isAvailable) {
                availableSeats++; // count only the available ones
            }
        }

        System.out.println("Available seats: " + availableSeats + " out of " + seatAvailability.length);
    }
}

package io.thecodeforge;

import java.util.ArrayList;
import java.util.List;

public class EnhancedForWithArrayList {
    public static void main(String[] args) {

        // Build a list of city names — ArrayList can grow, unlike a fixed array
        List<String> cityNames = new ArrayList<>();
        cityNames.add("Tokyo");
        cityNames.add("Nairobi");
        cityNames.add("São Paulo");
        cityNames.add("Oslo");
        cityNames.add("Sydney");

        System.out.println("Cities in our list:");

        // Works identically to the array version.
        // 'cityName' gets each String from the list one at a time.
        for (String cityName : cityNames) {
            System.out.println("  - " + cityName);
        }

        System.out.println();

        // Practical example: find all cities whose name is longer than 5 characters
        System.out.println("Cities with names longer than 5 characters:");
        for (String cityName : cityNames) {
            if (cityName.length() > 5) {
                // .length() gives us the number of characters in the String
                System.out.println("  " + cityName + " (" + cityName.length() + " chars)");
            }
        }

        System.out.println();

        // Another practical use: building a formatted summary string
        List<Integer> monthlyRevenue = new ArrayList<>();
        monthlyRevenue.add(42000);
        monthlyRevenue.add(38500);
        monthlyRevenue.add(51200);
        monthlyRevenue.add(47800);

        int annualTotal = 0;
        for (int revenue : monthlyRevenue) {
            annualTotal += revenue;
        }

        System.out.println("Total revenue across tracked months: $" + annualTotal);
    }
}

package io.thecodeforge;

public class EnhancedForLimitations {
    public static void main(String[] args) {

        // =====================================================
        // LIMITATION 1: Cannot modify the original array
        // =====================================================
        int[] temperatures = {22, 19, 25, 17, 30};

        // This looks like it should convert each temp from Celsius to Fahrenheit
        // but it will NOT change the original array.
        for (int temp : temperatures) {
            temp = (temp * 9 / 5) + 32; // modifies local copy ONLY
        }

        System.out.println("After attempted modification (enhanced for):");
        for (int temp : temperatures) {
            System.out.print(temp + " "); // still original Celsius values!
        }
        System.out.println();

        // FIX: Use a regular for loop with index to actually modify the array
        for (int i = 0; i < temperatures.length; i++) {
            temperatures[i] = (temperatures[i] * 9 / 5) + 32; // modifies the REAL array slot
        }

        System.out.println("After real modification (regular for with index):");
        for (int temp : temperatures) {
            System.out.print(temp + " ");
        }
        System.out.println();
        System.out.println();

        // =====================================================
        // LIMITATION 2: No access to the index
        // =====================================================
        String[] runnerNames = {"Grace", "Mateo", "Priya", "Liam"};

        // If you need the position (e.g. for a leaderboard), use a regular for loop
        System.out.println("Race results:");
        for (int position = 0; position < runnerNames.length; position++) {
            // position + 1 because humans count from 1, not 0
            System.out.println("  Place " + (position + 1) + ": " + runnerNames[position]);
        }
        System.out.println();

        // =====================================================
        // LIMITATION 3: Can't iterate two arrays together by index
        // =====================================================
        String[] subjectNames = {"Math", "Science", "History"};
        int[]    examScores   = {88, 74, 91};

        // To pair each subject with its score, you NEED a shared index
        System.out.println("Subject scores:");
        for (int i = 0; i < subjectNames.length; i++) {
            System.out.println("  " + subjectNames[i] + ": " + examScores[i]);
        }
    }
}

package io.thecodeforge;

import java.util.Iterator;
import java.util.NoSuchElementException;

// Custom class that implements Iterable to be used with enhanced for
class WeekDays implements Iterable<String> {
    private static final String[] DAYS = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};

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

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

            @Override
            public String next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return DAYS[index++];
            }
        };
    }
}

public class CustomIterableExample {
    public static void main(String[] args) {
        System.out.println("Days of the week:");
        for (String day : new WeekDays()) {
            System.out.println("  " + day);
        }
    }
}

package io.thecodeforge;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class PerformanceComparison {
    public static void main(String[] args) {
        // Small benchmark — not production-grade, but illustrative
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < 100_000; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        long start, end;

        // ArrayList indexed for - typical O(n)
        start = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < arrayList.size(); i++) {
            sum1 += arrayList.get(i);
        }
        end = System.nanoTime();
        System.out.println("Arraylist indexed loop: " + (end - start) / 1_000_000 + " ms");

        // ArrayList enhanced for
        start = System.nanoTime();
        int sum2 = 0;
        for (int val : arrayList) {
            sum2 += val;
        }
        end = System.nanoTime();
        System.out.println("ArrayList enhanced for: " + (end - start) / 1_000_000 + " ms");

        // LinkedList indexed for - O(n^2), do NOT run with 100k! (reduced size for demo)
        // Using regular for on LinkedList is a known anti-pattern.
        // Enhanced for is the correct choice.

        // LinkedList enhanced for
        start = System.nanoTime();
        int sum3 = 0;
        for (int val : linkedList) {
            sum3 += val;
        }
        end = System.nanoTime();
        System.out.println("LinkedList enhanced for: " + (end - start) / 1_000_000 + " ms");
    }
}

// io.thecodeforge
import java.util.*;

public class TransactionProcessor {
    static class Transaction {
        double amount;
        Transaction(double a) { this.amount = a; }
        void setAmount(double a) { this.amount = a; }
    }

    public static void main(String[] args) {
        List<Transaction> txs = new ArrayList<>(Arrays.asList(
            new Transaction(100), new Transaction(200)
        ));
        
        // This compiles but silently corrupts data
        for (Transaction tx : txs) {
            if (tx.amount > 150) {
                tx.setAmount(0);  // mutates original list
            }
        }
        
        System.out.println(txs.get(1).amount); // 0.0 — surprise
    }
}

// io.thecodeforge
import java.util.*;

public class IndexTracker {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        
        // Fragile manual index
        int i = 0;
        for (String name : names) {
            if (i == 1) { 
                System.out.println("Second: " + name);
            }
            i++;
        }
        
        // Better: explicit index loop
        for (int j = 0; j < names.size(); j++) {
            if (j == 1) {
                System.out.println("Second: " + names.get(j));
            }
        }
    }
}