Java Enhanced for Loop: Iterating Through Arrays and Collections

// Demonstrates the Java enhanced for loop.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class EnhancedForDemo {
    // A simple mutable object, to show rule two clearly.
    static class Box {
        String label;
        Box(String label) {
            this.label = label;
        }
    } public static void main(String[] args) {
        String[] cities = {
            "Dhaka", "London", "Tokyo"
        };
        int[] scores = {
            88, 74, 95
        };
        List<String> names = new ArrayList<>(List.of("Alex", "Sam", "Robin"));
        Map<String, Integer> totals = new HashMap<>();
        totals.put("Alex", 120);
        totals.put("Sam", 95);
        totals.put("Robin", 140);
        // 1) THE BASICS: no index, no bound, no increment to get wrong.
        System.out.println("cities:");
        for (String city : cities) {
            System.out.println("  " + city);
        } // 2) IT WORKS ON ANY PRIMITIVE ARRAY TOO.
        int best = scores[0];
        for (int score : scores) {
            if (score > best) {
                best = score;
            }
        } System.out.println("highest score: " + best);
        // 3) IT WORKS ON ANY COLLECTION, NOT JUST ARRAYS.
        System.out.println("names:");
        for (String name : names) {
            System.out.println("  " + name);
        } // 4) A MAP IS NOT ITERABLE ITSELF. Go via entrySet()
        //    when you need both the key and the value.
        System.out.println("totals:");
        for (Map.Entry<String, Integer> entry : totals.entrySet()) {
            System.out.println("  " + entry.getKey() + " -> " + entry.getValue());
        } // 5) RULE TWO, PART ONE: assigning the loop variable
        //    changes nothing, because each value is a fresh copy.
        int[] numbers = {
            1, 2, 3
        };
        for (int n : numbers) {
            n = 99;
            // legal, and completely ignored
        } System.out.println("after n = 99, first element is still " + numbers[0]);
        // 6) RULE TWO, PART TWO: you CAN modify the object behind
        //    the reference, because that is not the same thing.
        Box[] boxes = {
            new Box("first"), new Box("second")
        };
        for (Box box : boxes) {
            box.label = box.label.toUpperCase();
        } System.out.println("labels uppercased: " + boxes[0].label + ", " + boxes[1].label);
        // 7) RULE ONE: changing the SIZE mid-loop throws.
        //    This line is left commented because it would crash.
        // for (String name : names) {
        //     names.add("Jordan");       // ConcurrentModificationException
        // }
        // The safe alternatives, shown uncommented:
        List<String> growable = new ArrayList<>(names);
        growable.add("Jordan");
        System.out.println("copy grew safely to " + growable.size() + " items");
        // 8) WHEN YOU NEED THE INDEX, SWITCH DELIBERATELY.
        //    This is not a limitation to work around, it is a signal.
        for (int i = 0;
        i < names.size();
        i++) {
            System.out.println("  " +(i + 1) + ". " + names.get(i));
        } // 9) A TWO-DIMENSIONAL ARRAY NEEDS A NESTED for-each.
        int[][] grid = {
{
                1, 2, 3
            }, {
                4, 5, 6
            }
        };
        System.out.println("grid:");
        for (int[] row : grid) {
            // each element is itself an array
            for (int value : row) {
                System.out.print(value + " ");
            } System.out.println();
        }
    }
}/*
    ACTUAL OUTPUT:

        cities:
          Dhaka
          London
          Tokyo
        highest score: 95
        names:
          Alex
          Sam
          Robin
        totals:
          Robin -> 140
          Sam -> 95
          Alex -> 120
        after n = 99, first element is still 1
        labels uppercased: FIRST, SECOND
        copy grew safely to 4 items
1. Alex
2. Sam
3. Robin
        grid:
        1 2 3
        4 5 6

    THE FOUR THINGS TO REMEMBER
    1) Read the colon as the word in: for (X x : xs) means
       for each X in xs, put it into x.
    2) It removes the three things indexed loops get wrong: the
       start index, the ending bound and the increment.
    3) You cannot change the SIZE of a collection while iterating
       it, and you cannot assign the loop variable to change an
       element. You CAN modify the object behind the reference.
    4) Reach for it by default. Switch to an indexed for loop the
       moment you genuinely need the position.
*/