Loops — Middle Level¶

// This for-each loop:
for (String item : collection) {
    System.out.println(item);
}

// Compiles to equivalent of:
Iterator<String> it = collection.iterator();
while (it.hasNext()) {
    String item = it.next();
    System.out.println(item);
}

// Imperative — loop
List<String> result = new ArrayList<>();
for (String name : names) {
    if (name.startsWith("A")) {
        result.add(name.toUpperCase());
    }
}

// Declarative — Stream API
List<String> result = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// ❌ Invariant computation inside the loop
for (int i = 0; i < list.size(); i++) {
    double factor = Math.sqrt(config.getScalingFactor()); // Same every iteration
    results[i] = list.get(i) * factor;
}

// ✅ Hoisted manually
double factor = Math.sqrt(config.getScalingFactor());
int size = list.size();
for (int i = 0; i < size; i++) {
    results[i] = list.get(i) * factor;
}

// Original loop
for (int i = 0; i < 8; i++) {
    sum += arr[i];
}

// Conceptually unrolled (JIT may do this)
sum += arr[0] + arr[1] + arr[2] + arr[3]
     + arr[4] + arr[5] + arr[6] + arr[7];

public class Range implements Iterable<Integer> {
    private final int start, end;

    public Range(int start, int end) {
        this.start = start;
        this.end = end;
    }

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

            @Override
            public boolean hasNext() { return current < end; }

            @Override
            public Integer next() {
                if (!hasNext()) throw new NoSuchElementException();
                return current++;
            }
        };
    }
}

// Usage: for-each works automatically
for (int i : new Range(1, 5)) {
    System.out.println(i); // 1, 2, 3, 4
}

// Pre-Java 5: no generics, no for-each
List list = new ArrayList();
Iterator it = list.iterator();
while (it.hasNext()) {
    String s = (String) it.next(); // Unsafe cast
}

import java.util.*;

public class SafeRemoval {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(
            List.of("Alice", "Bob", "Charlie", "David", "Eve")
        );

        // Approach 1: Iterator.remove()
        Iterator<String> it = names.iterator();
        while (it.hasNext()) {
            if (it.next().length() <= 3) {
                it.remove(); // Safe — uses iterator's own remove
            }
        }
        System.out.println(names); // [Alice, Charlie, David]

        // Approach 2: removeIf (Java 8+) — most idiomatic
        names.removeIf(name -> name.length() > 5);
        System.out.println(names); // [Alice, David]

        // Approach 3: Reverse index loop for ArrayList
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
        for (int i = nums.size() - 1; i >= 0; i--) {
            if (nums.get(i) % 2 == 0) {
                nums.remove(i); // Safe — removing from end
            }
        }
        System.out.println(nums); // [1, 3, 5]
    }
}

import java.util.*;
import java.util.stream.*;

public class LoopVsStream {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            numbers.add(i);
        }

        // Imperative loop
        long start1 = System.nanoTime();
        long sum1 = 0;
        for (int n : numbers) {
            if (n % 2 == 0) {
                sum1 += n * 2L;
            }
        }
        long elapsed1 = System.nanoTime() - start1;

        // Stream API
        long start2 = System.nanoTime();
        long sum2 = numbers.stream()
            .filter(n -> n % 2 == 0)
            .mapToLong(n -> n * 2L)
            .sum();
        long elapsed2 = System.nanoTime() - start2;

        System.out.printf("Loop:   %d ns, sum=%d%n", elapsed1, sum1);
        System.out.printf("Stream: %d ns, sum=%d%n", elapsed2, sum2);
    }
}

public class SlidingWindow {
    public static int maxSumSubarray(int[] arr, int k) {
        int windowSum = 0;
        for (int i = 0; i < k; i++) {
            windowSum += arr[i]; // Initialize first window
        }

        int maxSum = windowSum;
        for (int i = k; i < arr.length; i++) {
            windowSum += arr[i] - arr[i - k]; // Slide: add right, remove left
            maxSum = Math.max(maxSum, windowSum);
        }
        return maxSum;
    }

    public static void main(String[] args) {
        int[] data = {2, 1, 5, 1, 3, 2};
        System.out.println(maxSumSubarray(data, 3)); // 9 (5+1+3)
    }
}

public class TwoPointer {
    public static boolean isPalindrome(String s) {
        int left = 0, right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isPalindrome("racecar")); // true
        System.out.println(isPalindrome("hello"));   // false
    }
}

import java.io.*;

public class SentinelLoop {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
        String line;
        // null is the sentinel: readLine() returns null at EOF
        while ((line = reader.readLine()) != null) {
            System.out.println(line.trim());
        }
        reader.close();
    }
}

import java.util.*;

public class BatchProcessor {
    private static final int BATCH_SIZE = 100;

    public static <T> void processBatches(List<T> items, java.util.function.Consumer<List<T>> processor) {
        for (int i = 0; i < items.size(); i += BATCH_SIZE) {
            int end = Math.min(i + BATCH_SIZE, items.size());
            List<T> batch = items.subList(i, end);
            processor.accept(batch);
            System.out.printf("Processed batch %d-%d of %d%n", i, end - 1, items.size());
        }
    }

    public static void main(String[] args) {
        List<Integer> data = new ArrayList<>();
        for (int i = 0; i < 350; i++) data.add(i);

        processBatches(data, batch ->
            System.out.println("  Batch size: " + batch.size())
        );
    }
}

public class RetryLoop {
    public static <T> T retryWithBackoff(java.util.concurrent.Callable<T> task,
                                          int maxRetries, long initialDelay) throws Exception {
        int attempt = 0;
        while (true) {
            try {
                return task.call();
            } catch (Exception e) {
                attempt++;
                if (attempt >= maxRetries) {
                    throw e;
                }
                long delay = initialDelay * (1L << (attempt - 1)); // Exponential
                System.out.printf("Attempt %d failed, retrying in %d ms...%n", attempt, delay);
                Thread.sleep(delay);
            }
        }
    }
}

// ❌ Cryptic
for (int i = 0; i < u.size(); i++) {
    if (u.get(i).a > 18 && u.get(i).s) {
        r.add(u.get(i));
    }
}

// ✅ Self-documenting
for (User user : users) {
    if (user.getAge() > 18 && user.isActive()) {
        eligibleUsers.add(user);
    }
}

// ❌ Loop doing validation + transformation + persistence
for (Order order : orders) {
    if (order.getTotal() > 0 && order.getCustomer() != null) {
        order.setTotal(order.getTotal() * 1.1); // Add tax
        database.save(order);
        emailService.sendConfirmation(order);
    }
}

// ✅ Separate concerns
List<Order> validOrders = orders.stream()
    .filter(this::isValidOrder)
    .collect(Collectors.toList());

for (Order order : validOrders) {
    applyTax(order);
    database.save(order);
    emailService.sendConfirmation(order);
}

import java.sql.*;

public class ResourceLoop {
    public void processResults(Connection conn) throws SQLException {
        try (PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users");
             ResultSet rs = stmt.executeQuery()) {

            while (rs.next()) {
                try {
                    processRow(rs);
                } catch (Exception e) {
                    // Log but continue — don't let one bad row stop processing
                    System.err.println("Error processing row " + rs.getInt("id") + ": " + e.getMessage());
                }
            }
        } // Auto-closed by try-with-resources
    }

    private void processRow(ResultSet rs) throws SQLException {
        System.out.println(rs.getString("name"));
    }
}

import java.util.*;

public class ErrorCollector {
    public static List<String> validateAll(List<String> inputs) {
        List<String> errors = new ArrayList<>();
        for (int i = 0; i < inputs.size(); i++) {
            String input = inputs.get(i);
            if (input == null || input.isBlank()) {
                errors.add("Input at index " + i + " is empty");
            } else if (input.length() > 100) {
                errors.add("Input at index " + i + " exceeds max length");
            }
        }
        return errors; // Return all errors, not just the first one
    }
}

// ❌ Dangerous — each iteration runs a potentially catastrophic regex
for (String input : userInputs) {
    if (input.matches("(a+)+b")) { // Exponential backtracking
        process(input);
    }
}

// ✅ Safe — compile regex once, use bounded matching
Pattern pattern = Pattern.compile("a+b"); // Simplified, no catastrophic backtracking
for (String input : userInputs) {
    if (pattern.matcher(input).matches()) {
        process(input);
    }
}

// ❌ Vulnerable — file could change between check and read
for (File file : directory.listFiles()) {
    if (file.exists() && file.canRead()) {
        // File might be deleted or replaced by symlink between these lines
        processFile(file);
    }
}

// ✅ Safer — handle the exception
for (File file : directory.listFiles()) {
    try {
        processFile(file);
    } catch (IOException e) {
        log.warn("Could not process file: {}", file.getName(), e);
    }
}

import org.openjdk.jmh.annotations.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 5)
@Measurement(iterations = 10)
public class LoopBenchmark {

    private int[] array;
    private List<Integer> arrayList;

    @Setup
    public void setup() {
        array = new int[10_000];
        arrayList = new ArrayList<>(10_000);
        for (int i = 0; i < 10_000; i++) {
            array[i] = i;
            arrayList.add(i);
        }
    }

    @Benchmark
    public long classicForArray() {
        long sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
    }

    @Benchmark
    public long forEachArray() {
        long sum = 0;
        for (int n : array) {
            sum += n;
        }
        return sum;
    }

    @Benchmark
    public long streamArrayList() {
        return arrayList.stream()
            .mapToLong(Integer::longValue)
            .sum();
    }

    @Benchmark
    public long forEachArrayList() {
        long sum = 0;
        for (int n : arrayList) {
            sum += n;
        }
        return sum;
    }
}

// ❌ Counter overflows — infinite loop!
for (int i = Integer.MAX_VALUE - 1; i >= 0; i++) {
    // i wraps from MAX_VALUE to MIN_VALUE, which is < 0... but wait
    // actually i goes: MAX_VALUE-1, MAX_VALUE, MIN_VALUE (< 0, loop ends)
    // But if condition were i >= Integer.MIN_VALUE, it would be truly infinite
}

// ✅ Use long for very large ranges
for (long i = 0; i < 3_000_000_000L; i++) {
    // int would overflow at ~2.1 billion
}

// ❌ May not terminate due to floating point precision
for (double d = 0.0; d != 1.0; d += 0.1) {
    System.out.println(d); // 0.1 + 0.1 + ... never exactly equals 1.0
}

// ✅ Use integer counter and calculate
for (int i = 0; i < 10; i++) {
    double d = i * 0.1;
    System.out.println(d);
}

List<String> items = null;
// ❌ Throws NullPointerException
for (String item : items) { ... }

// ✅ Guard against null
for (String item : (items != null ? items : Collections.emptyList())) { ... }
// Or better: ensure items is never null

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
nums.removeIf(n -> n % 2 == 0);
System.out.println(nums);

int count = 0;
for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (j == 5) continue;
        count++;
    }
}
System.out.println(count);