feat(IteratorForEachLoop): add demo comparing for-each, Iterator, and ListIterator

What
- Added IteratorForEachLoop class with examples of three traversal techniques:
  1. For-each loop:
     - Iterates list of integers [1,2,3,4,5].
     - Prints each element with "For-each element: ".
  2. Iterator:
     - Demonstrates forward traversal with hasNext()/next().
     - Creates separate list "numbers" and removes even numbers safely with itr.remove().
     - Prints result after removals → [1, 3, 5].
  3. ListIterator:
     - Demonstrates bidirectional iterator.
     - Iterates "numbers" with hasNext()/next().
     - Shows potential to modify elements with set() or add().

Why
- Explains trade-offs between different iteration techniques.
- Demonstrates safe removal of elements during iteration (Iterator.remove()).
- Shows enhanced functionality of ListIterator for bidirectional traversal and element modification.
- Highlights why for-each cannot safely remove elements.

How
- For-each loop over list: syntactic sugar over Iterator, read-only.
- Iterator:
  - numbers.iterator() returns forward-only cursor.
  - While loop checks hasNext(), consumes next().
  - Even numbers removed safely via itr.remove().
- ListIterator:
  - numbers.listIterator() allows traversal in both directions.
  - Iterates forward in demo, prints values.
  - Could update elements using set(), add(), remove().

Logic
- Inputs:
  - list = [1,2,3,4,5].
  - numbers = [1,2,3,4,5].
- Outputs:
  - For-each prints 1–5.
  - Iterator prints 1–5, then removes evens, leaving [1,3,5].
  - ListIterator prints 1,3,5.
- Flow:
  1. For-each demonstrates basic traversal.
  2. Iterator shows safe removal in traversal.
  3. ListIterator highlights richer API (bidirectional, modifications).
- Edge cases:
  - Removing in for-each causes ConcurrentModificationException.
  - Calling next()/previous() without hasNext()/hasPrevious() throws NoSuchElementException.
- Complexity / performance: O(n) for all traversals.
- Concurrency / thread-safety: Iterators are fail-fast; not safe with concurrent modification outside iterator.
- Error handling: Not needed in demo.

Real-life applications
- For-each: simple reading (printing, aggregating).
- Iterator: filtering/removing unwanted elements during traversal.
- ListIterator: implementing editors, undo/redo stacks, or interactive traversals where moving both forward/backward is required.

Notes
- For-each is concise, but limited.
- Iterator is the most common low-level API for traversal + safe removal.
- ListIterator is list-specific, with powerful bidirectional operations.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/ArrayList/Iterator/src/IteratorForEachLoop.java

@@ -0,0 +1,105 @@
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class IteratorForEachLoop {
+    public static void main(String[] args) {
+        // Create an ArrayList of Integers
+        ArrayList<Integer> list = new ArrayList<>();
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        list.add(4);
+        list.add(5);
+
+        // 1. Using For-Each Loop
+        for (int i : list) {
+            System.out.println("For-each element: " + i);
+        }
+
+        // 2. Using Iterator (Forward Traversal)
+        System.out.println("Using Iterator:");
+        Iterator<Integer> iterator = list.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+
+        // 3. Removing Elements Using Iterator
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        numbers.add(4);
+        numbers.add(5);
+
+        /*
+         * NOTE: Removing elements directly inside a for-each loop
+         * causes ConcurrentModificationException.
+         * Example (invalid):
+         *
+         * for (Integer number : numbers) {
+         *     if (number % 2 == 0) {
+         *         numbers.remove(number); //  Not allowed
+         *     }
+         * }
+
+         * Correct way: use Iterator.remove()
+         */
+        System.out.println("Using Iterator to Remove Even Numbers:");
+        Iterator<Integer> itr = numbers.iterator();
+        while (itr.hasNext()) {
+            Integer number = itr.next();
+            if (number % 2 == 0) {
+                itr.remove(); // Safe removal
+            }
+        }
+        System.out.println("After removing evens: " + numbers); // [1, 3, 5]
+
+
+        // 4. Using ListIterator (Bidirectional Traversal)
+
+        /* ListIterator provides:
+         * - Forward iteration (hasNext, next)
+         * - Backward iteration (hasPrevious, previous)
+         * - Ability to modify elements (set, add, remove)
+         */
+        System.out.println("Using ListIterator:");
+
+        ListIterator<Integer> listIterator = numbers.listIterator();
+        while (listIterator.hasNext()) {
+            Integer val = listIterator.next();
+            System.out.println(val);
+
+            // Example: You could update elements here
+            // listIterator.set(val * 10);
+        }
+    }
+}
+
+/*
+1. For-Each Loop
+   - Simplest way to iterate a collection.
+   - Read-only iteration (cannot safely remove elements).
+
+2. Iterator
+   - Provides forward-only traversal of a collection.
+   - Methods:
+       hasNext() → check if more elements exist.
+       next() → fetch next element.
+       remove() → safely remove the last returned element.
+   - Important: Use remove() of Iterator, not List.remove(), to avoid ConcurrentModificationException.
+
+3. ListIterator
+   - An enhanced iterator for Lists.
+   - Provides bidirectional traversal:
+       hasPrevious(), previous().
+   - Supports modification:
+       set(newValue), add(newElement), remove().
+   - More powerful than a simple Iterator.
+
+4. Practical Notes
+   - Use for-each for simple reading.
+   - Use Iterator when you may need to remove while traversing.
+   - Use ListIterator when you need bidirectional traversal or in-place updates.
+*/