Java Language Specification — Loops¶

for (int x : array) { body }

for (int i = 0, len = array.length; i < len; i++) {
    int x = array[i];
    body
}

for (T x : iterable) { body }

Iterator<T> iter = iterable.iterator();
while (iter.hasNext()) {
    T x = iter.next();
    body
}

for (int i = 0; i < 5; i++) {
    // i is in scope here
}
// i is NOT in scope here

// Two for loops can reuse same variable name:
for (int i = 0; i < 3; i++) { }
for (int i = 0; i < 3; i++) { }  // OK — each for creates new scope

// Legal: multiple variables of same type
for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println(i + " " + j);
}
// Illegal: mixed types in ForInit
// for (int i = 0, long j = 0; ...) { }  // COMPILE ERROR

int[] numbers = {1, 2, 3};
for (int n : numbers) {
    n = n * 2;  // modifies local copy only — does NOT change numbers array
}
System.out.println(java.util.Arrays.toString(numbers));  // [1, 2, 3] unchanged

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer;  // exits BOTH loops
        }
        System.out.println(i + "," + j);
    }
}
// Prints: 0,0  0,1  0,2  1,0  (stops here)

// In for: continue goes to ForUpdate
for (int i = 0; i < 5; i++) {
    if (i == 3) continue;  // jumps to i++
    System.out.print(i + " ");  // 0 1 2 4
}

// In while: continue goes to condition check
int j = 0;
while (j < 5) {
    j++;
    if (j == 3) continue;  // jumps to condition
    System.out.print(j + " ");  // 1 2 4 5
}

int n = 1;
while (true) {
    if (n > 100) break;
    n *= 2;
}
System.out.println(n);  // 128 — variable n is definitely assigned after loop
// because break guarantees the loop exits with n defined

// Example 1: All Loop Types
// File: LoopTypes.java
import java.util.List;

public class LoopTypes {
    public static void main(String[] args) {
        // while loop
        int i = 1;
        int product = 1;
        while (i <= 5) {
            product *= i;
            i++;
        }
        System.out.println("5! = " + product);  // 120

        // do-while (executes at least once)
        int n = 10;
        do {
            System.out.print(n + " ");
            n -= 3;
        } while (n > 0);
        System.out.println();  // 10 7 4 1

        // Basic for loop
        int sum = 0;
        for (int j = 1; j <= 100; j++) {
            sum += j;
        }
        System.out.println("Sum 1-100: " + sum);  // 5050

        // for with multiple variables
        for (int lo = 0, hi = 10; lo < hi; lo++, hi--) {
            System.out.print("[" + lo + "," + hi + "] ");
        }
        System.out.println();  // [0,10] [1,9] [2,8] [3,7] [4,6]

        // Enhanced for — array
        int[] primes = {2, 3, 5, 7, 11};
        for (int p : primes) {
            System.out.print(p + " ");
        }
        System.out.println();  // 2 3 5 7 11

        // Enhanced for — Iterable
        List<String> fruits = List.of("apple", "banana", "cherry");
        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

// Example 2: break and continue
// File: BreakContinue.java
public class BreakContinue {
    public static void main(String[] args) {
        // break: exit loop early
        for (int i = 0; i < 100; i++) {
            if (i * i > 50) {
                System.out.println("First i where i*i > 50: " + i);
                break;
            }
        }  // 8

        // continue: skip current iteration
        System.out.print("Odd numbers: ");
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) continue;  // skip even
            System.out.print(i + " ");
        }
        System.out.println();  // 1 3 5 7 9

        // Labeled break for nested loops
        outer:
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (i + j == 5) {
                    System.out.println("First pair summing to 5: " + i + "+" + j);
                    break outer;
                }
            }
        }

        // Labeled continue
        outer:
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (j == 2) continue outer;  // skip rest of outer iteration
                System.out.println(i + "," + j);
            }
        }
        // Prints: 1,1   2,1   3,1  (j=2 triggers continue outer each time)
    }
}

// Example 3: Common Loop Patterns
// File: LoopPatterns.java
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class LoopPatterns {

    // Binary search
    static int binarySearch(int[] arr, int target) {
        int lo = 0, hi = arr.length - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;  // avoids overflow vs (lo+hi)/2
            if (arr[mid] == target) return mid;
            if (arr[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }

    // Safe removal during iteration
    static List<Integer> removeEvens(List<Integer> nums) {
        List<Integer> copy = new ArrayList<>(nums);
        Iterator<Integer> it = copy.iterator();
        while (it.hasNext()) {
            if (it.next() % 2 == 0) {
                it.remove();  // safe: via iterator
            }
        }
        return copy;
    }

    public static void main(String[] args) {
        int[] sorted = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
        System.out.println("Index of 23: " + binarySearch(sorted, 23));   // 5
        System.out.println("Index of 50: " + binarySearch(sorted, 50));   // -1

        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8));
        System.out.println("After removing evens: " + removeEvens(nums));  // [1, 3, 5, 7]

        // Fibonacci with while
        long a = 0, b = 1;
        System.out.print("Fibonacci: ");
        while (b < 1000) {
            System.out.print(b + " ");
            long next = a + b;
            a = b;
            b = next;
        }
        System.out.println();

        // Triangle pattern with nested loops
        for (int row = 1; row <= 5; row++) {
            for (int col = 1; col <= row; col++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

// Example 4: Loop with Streams (Alternative, Java 8+)
// File: StreamLoops.java
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamLoops {
    public static void main(String[] args) {
        // for(int i=0; i<10; i++) equivalent
        IntStream.range(0, 10).forEach(i -> System.out.print(i + " "));
        System.out.println();

        // for(int i=1; i<=10; i++) equivalent
        IntStream.rangeClosed(1, 10)
            .filter(i -> i % 2 != 0)
            .forEach(i -> System.out.print(i + " "));
        System.out.println();  // odd numbers 1-10

        // while (condition) with Stream.iterate (Java 9+)
        Stream.iterate(1, n -> n <= 1000, n -> n * 2)
            .forEach(n -> System.out.print(n + " "));
        System.out.println();  // 1 2 4 8 ... 512

        // Sum with reduce
        int sum = IntStream.rangeClosed(1, 100).sum();
        System.out.println("Sum 1-100: " + sum);  // 5050

        // Parallel stream (automatic parallelism for large data)
        long count = IntStream.rangeClosed(2, 1_000_000)
            .parallel()
            .filter(StreamLoops::isPrime)
            .count();
        System.out.println("Primes up to 1M: " + count);
    }

    static boolean isPrime(int n) {
        if (n < 2) return false;
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) return false;
        }
        return true;
    }
}

// Example 5: Advanced Loop Usage — Virtual Threads (Java 21)
// File: VirtualThreadLoop.java
import java.util.concurrent.Executors;

public class VirtualThreadLoop {
    public static void main(String[] args) throws InterruptedException {
        // Traditional: blocking loop in platform thread
        int[] counter = {0};
        for (int i = 0; i < 10; i++) {
            counter[0] += computeValue(i);
        }
        System.out.println("Sequential result: " + counter[0]);

        // Virtual threads: parallel loop-like pattern
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var futures = new java.util.concurrent.Future[10];
            for (int i = 0; i < 10; i++) {
                final int idx = i;
                futures[idx] = executor.submit(() -> computeValue(idx));
            }
            // Collect results
            long total = 0;
            for (var f : futures) {
                try {
                    total += (Integer) f.get();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Parallel result: " + total);
        }

        // do-while for retry pattern
        int attempts = 0;
        boolean success;
        do {
            success = tryOperation(++attempts);
            System.out.println("Attempt " + attempts + ": " + (success ? "ok" : "retry"));
        } while (!success && attempts < 5);
    }

    static int computeValue(int i) {
        return i * i;
    }

    static boolean tryOperation(int attempt) {
        return attempt >= 3;  // succeeds on 3rd attempt
    }
}