Iterator & Iterable — Fail-Fast vs Fail-Safe

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

    // Default methods (Java 8+)
    default void forEach(Consumer<? super T> action) { ... }
    default Spliterator<T> spliterator() { ... }
}

// What you write:
for (String item : collection) {
    System.out.println(item);
}

// What the compiler generates:
Iterator<String> it = collection.iterator();
while (it.hasNext()) {
    String item = it.next();
    System.out.println(item);
}

public interface Iterator<E> {
    boolean hasNext();   // Are there more elements?
    E next();           // Return current element, advance cursor

    default void remove() {  // Remove last element returned by next()
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) { ... }
}

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

Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    if (name.startsWith("B")) {
        it.remove();  // SAFE — uses iterator's remove
    }
}
// names = [Alice, Charlie]

// Inside ArrayList
protected transient int modCount = 0;  // incremented on add/remove/clear

// Inside ArrayList$Itr (the iterator)
int expectedModCount = modCount;

public E next() {
    checkForComodification();  // <-- the guard
    // ... return element
}

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

// FAILS — modifying list during iteration
List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
for (Integer n : nums) {
    if (n == 3) {
        nums.remove(n);  // ConcurrentModificationException!
    }
}

// FAILS — HashMap during iteration
Map<String, Integer> map = new HashMap<>(Map.of("a", 1, "b", 2));
for (Map.Entry<String, Integer> e : map.entrySet()) {
    if (e.getValue() == 1) {
        map.remove(e.getKey());  // ConcurrentModificationException!
    }
}

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(List.of("A", "B", "C"));

// Iterator works on a SNAPSHOT of the array at creation time
Iterator<String> it = list.iterator();

list.add("D");  // Creates a new internal array copy

while (it.hasNext()) {
    System.out.println(it.next());  // Prints A, B, C (NOT D)
}
// No ConcurrentModificationException!

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

// Iterator MAY or MAY NOT see concurrent modifications
for (Map.Entry<String, Integer> e : map.entrySet()) {
    map.put("d", 4);  // No exception, iterator may or may not see "d"
    System.out.println(e);
}

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();
    void remove();     // Remove last returned element
    void set(E e);     // Replace last returned element
    void add(E e);     // Insert before next element
}

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));

ListIterator<String> lit = list.listIterator(2);  // Start at index 2

// Traverse backward
while (lit.hasPrevious()) {
    String prev = lit.previous();
    if (prev.equals("B")) {
        lit.set("B_MODIFIED");  // Replace B in-place
    }
}

// Traverse forward and add
lit = list.listIterator();
while (lit.hasNext()) {
    String val = lit.next();
    if (val.equals("C")) {
        lit.add("C2");  // Insert C2 after C
    }
}
// Result: [A, B_MODIFIED, C, C2, D]

public interface Spliterator<T> {
    boolean tryAdvance(Consumer<? super T> action);  // Process one element
    Spliterator<T> trySplit();                       // Split into two halves
    long estimateSize();                             // Remaining elements estimate
    int characteristics();                           // ORDERED, DISTINCT, SORTED, etc.
}

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);
Spliterator<Integer> sp1 = numbers.spliterator();
Spliterator<Integer> sp2 = sp1.trySplit();  // sp2 gets first half

// sp2: [1, 2, 3, 4]
sp2.forEachRemaining(System.out::println);

// sp1: [5, 6, 7, 8] (remaining)
sp1.forEachRemaining(System.out::println);

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

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

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

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

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

    // Usage:
    public static void main(String[] args) {
        NumberRange range = new NumberRange(1, 5);

        // Works with enhanced for-loop!
        for (int n : range) {
            System.out.println(n);  // 1, 2, 3, 4, 5
        }

        // Works with streams!
        range.forEach(System.out::println);

        // Works with Stream API via spliterator
        StreamSupport.stream(range.spliterator(), false)
                     .filter(n -> n % 2 == 0)
                     .forEach(System.out::println);  // 2, 4
    }
}

// WRONG — throws ConcurrentModificationException
List<String> items = new ArrayList<>(List.of("a", "b", "c"));
for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);  // Structural modification!
    }
}

// CORRECT — use Iterator.remove()
Iterator<String> it = items.iterator();
while (it.hasNext()) {
    if (it.next().equals("b")) {
        it.remove();  // Safe!
    }
}

// CORRECT — use removeIf() (Java 8+)
items.removeIf(item -> item.equals("b"));

// WRONG — streams rely on fail-fast iterators internally
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
list.stream()
    .filter(s -> s.equals("a"))
    .forEach(s -> list.remove(s));  // ConcurrentModificationException!

// CORRECT — collect then remove
List<String> toRemove = list.stream()
    .filter(s -> s.equals("a"))
    .collect(Collectors.toList());
list.removeAll(toRemove);

// WRONG — one iterator modifies, other breaks
List<String> list = new ArrayList<>(List.of("x", "y", "z"));
Iterator<String> it1 = list.iterator();
Iterator<String> it2 = list.iterator();

it1.next();
it1.remove();  // Modifies list

it2.next();  // ConcurrentModificationException! (it2's expectedModCount is stale)

CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>(List.of("a", "b", "c"));
Iterator<String> it = cowList.iterator();
it.next();
it.remove();  // UnsupportedOperationException!

// CORRECT — use the list's methods directly (thread-safe)
cowList.remove("b");