Java Iterator/ListIterator — Silent Data Loss from remove()

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TaskQueueIterator {

    public static void main(String[] args) {

        // A simple task queue — imagine these are pending support tickets
        List<String> taskQueue = new ArrayList<>();
        taskQueue.add("Send welcome email");
        taskQueue.add("URGENT: Fix login bug");
        taskQueue.add("Update user profile");
        taskQueue.add("URGENT: Payment gateway down");
        taskQueue.add("Archive old records");

        System.out.println("=== Processing Task Queue ===");

        // Grab an iterator from the list — the cursor starts BEFORE the first element
        Iterator<String> taskIterator = taskQueue.iterator();

        while (taskIterator.hasNext()) {          // hasNext() peeks — doesn't consume
            String currentTask = taskIterator.next(); // next() consumes and advances cursor

            System.out.println("Checking: " + currentTask);

            // Business rule: remove completed urgent tasks from the live queue
            // Using iterator.remove() — NOT taskQueue.remove() — keeps iterator in sync
            if (currentTask.startsWith("URGENT")) {
                System.out.println("  -> Escalating and removing from queue: " + currentTask);
                taskIterator.remove(); // SAFE removal — no ConcurrentModificationException
            }
        }

        System.out.println("\n=== Remaining Tasks ===");
        // For-each is fine here since we're done modifying
        for (String remainingTask : taskQueue) {
            System.out.println("  - " + remainingTask);
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class PlaylistManager {

    public static void main(String[] args) {

        List<String> playlist = new ArrayList<>();
        playlist.add("Intro Track");
        playlist.add("Main Theme");
        playlist.add("Bridge");
        playlist.add("Main Theme");  // duplicate — will be replaced
        playlist.add("Outro");

        System.out.println("=== Original Playlist ===");
        playlist.forEach(track -> System.out.println("  " + track));

        // Get a ListIterator starting at the BEGINNING (index 0)
        ListIterator<String> playlistEditor = playlist.listIterator();

        System.out.println("\n=== Editing Playlist (Forward Pass) ===");

        while (playlistEditor.hasNext()) {
            // nextIndex() tells us WHERE we are before we consume the element
            int position = playlistEditor.nextIndex();
            String track = playlistEditor.next(); // advance cursor, get element

            System.out.println("Position " + position + ": " + track);

            // Replace duplicate 'Main Theme' at position 3 with 'Reprise'
            if (track.equals("Main Theme") && position == 3) {
                playlistEditor.set("Main Theme (Reprise)"); // replaces in-place, no index needed
                System.out.println("  -> Replaced with: Main Theme (Reprise)");
            }
        }

        System.out.println("\n=== Rewinding (Backward Pass) ===");

        // Cursor is now at the END — walk backwards using hasPrevious()
        while (playlistEditor.hasPrevious()) {
            int position = playlistEditor.previousIndex();
            String track = playlistEditor.previous(); // move cursor back, get element
            System.out.println("Position " + position + ": " + track);
        }

        System.out.println("\n=== Final Playlist ===");
        playlist.forEach(track -> System.out.println("  " + track));
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class SafeCollectionModification {

    public static void main(String[] args) {

        List<Integer> temperatures = new ArrayList<>();
        temperatures.add(72);
        temperatures.add(85);
        temperatures.add(91);  // heatwave threshold
        temperatures.add(68);
        temperatures.add(95);  // heatwave threshold

        System.out.println("=== BROKEN: This will throw ConcurrentModificationException ===");
        try {
            for (Integer temp : temperatures) {
                if (temp > 90) {
                    temperatures.remove(temp); // modifying the list WHILE for-each iterates it
                }
            }
        } catch (java.util.ConcurrentModificationException e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
            System.out.println("Reason: for-each hides an Iterator — we modified the list externally");
        }

        // Reset the data
        temperatures.clear();
        temperatures.add(72);
        temperatures.add(85);
        temperatures.add(91);
        temperatures.add(68);
        temperatures.add(95);

        System.out.println("\n=== FIXED: Use iterator.remove() for safe removal ===");
        Iterator<Integer> tempIterator = temperatures.iterator();
        while (tempIterator.hasNext()) {
            int reading = tempIterator.next();
            if (reading > 90) {
                System.out.println("Removing heatwave reading: " + reading);
                tempIterator.remove(); // iterator stays in sync — no exception
            }
        }
        System.out.println("Safe temperatures remaining: " + temperatures);

        // Adding elements during iteration — Iterator has no add(), so use collect-then-apply
        System.out.println("\n=== Adding Elements: Collect-Then-Apply Pattern ===");
        List<Integer> extraReadings = new ArrayList<>();
        Iterator<Integer> scanIterator = temperatures.iterator();
        while (scanIterator.hasNext()) {
            int reading = scanIterator.next();
            // Flag each reading that needs a follow-up measurement added after it
            if (reading < 75) {
                extraReadings.add(reading - 2); // simulated second sensor reading
            }
        }
        temperatures.addAll(extraReadings); // apply additions AFTER iteration is complete
        System.out.println("Final temperature list: " + temperatures);
    }
}

import java.util.*;

public class PerformanceComparison {
    public static void main(String[] args) {
        int size = 100_000;
        List<Integer> arrayList = new ArrayList<>(size);
        List<Integer> linkedList = new LinkedList<>();
        for (int i = 0; i < size; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        // Warm up
        for (int i = 0; i < 3; i++) {
            iterateWithIndex(arrayList);
            iterateWithIterator(arrayList);
            iterateWithIndex(linkedList);  // first run may include class loading
        }

        long start, end;

        // ArrayList index-based
        start = System.nanoTime();
        iterateWithIndex(arrayList);
        end = System.nanoTime();
        System.out.println("ArrayList index-loop: " + (end - start) / 1_000_000 + " ms");

        // ArrayList iterator
        start = System.nanoTime();
        iterateWithIterator(arrayList);
        end = System.nanoTime();
        System.out.println("ArrayList iterator: " + (end - start) / 1_000_000 + " ms");

        // LinkedList index-based — SLOW
        start = System.nanoTime();
        iterateWithIndex(linkedList);
        end = System.nanoTime();
        System.out.println("LinkedList index-loop: " + (end - start) / 1_000_000 + " ms");

        // LinkedList iterator
        start = System.nanoTime();
        iterateWithIterator(linkedList);
        end = System.nanoTime();
        System.out.println("LinkedList iterator: " + (end - start) / 1_000_000 + " ms");
    }

    static long sum = 0;  // prevent optimisation

    static void iterateWithIndex(List<Integer> list) {
        sum = 0;
        for (int i = 0; i < list.size(); i++) {
            sum += list.get(i);
        }
    }

    static void iterateWithIterator(List<Integer> list) {
        sum = 0;
        for (int val : list) {
            sum += val;
        }
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class AuditLogInsertion {

    public static void main(String[] args) {
        List<String> logs = new ArrayList<>();
        logs.add("2026-05-01 10:00: User login");
        logs.add("2026-05-01 10:05: Order placed #1234");
        logs.add("2026-05-01 10:07: Payment processed");
        logs.add("2026-05-01 10:10: User logout");

        ListIterator<String> it = logs.listIterator();

        while (it.hasNext()) {
            String logEntry = it.next();
            if (logEntry.contains("Order placed")) {
                // Insert an audit log entry right after the order placed event
                // Cursor is now between "Order placed" and "Payment processed"
                it.add("2026-05-01 10:06: Order validation started"); // inserts BEFORE cursor -> after current element
                // After add(), the cursor is between the new entry and "Payment processed"
                // Next next() returns "Payment processed"
            }
        }

        System.out.println("=== Audit Log with Insertions ===");
        logs.forEach(System.out::println);
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class BidirectionalTraversal {
    public static void main(String[] args) {
        List<String> commitMessages = new ArrayList<>();
        commitMessages.add("Fix null pointer on login");
        commitMessages.add("Add rate limiting middleware");
        commitMessages.add("Refactor DB connection pool");

        ListIterator<String> it = commitMessages.listIterator();

        // Forward traversal
        System.out.println("Forward:");
        while (it.hasNext()) {
            System.out.println("  " + it.next());
        }

        // Backward traversal — same iterator, now at end
        System.out.println("Backward:");
        while (it.hasPrevious()) {
            System.out.println("  " + it.previous());
        }
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class SetAndAddRules {
    public static void main(String[] args) {
        List<String> tasks = new ArrayList<>(List.of("auth", "caching", "logging"));
        ListIterator<String> it = tasks.listIterator();

        // Move forward once
        it.next(); // returns "auth"
        it.set("oauth"); // replaces "auth" with "oauth"

        // add() inserts BEFORE cursor
        it.add("rate-limiting"); // cursor now between "rate-limiting" and "caching"
        // it.set("x"); // IllegalStateException — last access was add()

        it.next(); // returns "caching"
        System.out.println(tasks);
    }
}

// io.thecodeforge — java tutorial

import java.util.*;

public class IteratorVsListIterator {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>(List.of(85, 90, 78));

        // Iterator — forward only, works with any Collection
        Iterator<Integer> it = scores.iterator();
        while (it.hasNext()) {
            int s = it.next();
            if (s < 80) it.remove();
        }

        // ListIterator — bidirectional, can set/add
        ListIterator<Integer> lit = scores.listIterator();
        while (lit.hasNext()) {
            int s = lit.next();
            if (s == 85) lit.set(86);
        }

        System.out.println(scores);
    }
}

// io.thecodeforge — java tutorial
import java.util.*;

public class EnumerationExample {
    public static void main(String[] args) {
        Vector<String> legacyVector = new Vector<>();
        legacyVector.add("Java");
        legacyVector.add("Enumeration");
        legacyVector.add("Legacy");

        Enumeration<String> en = legacyVector.elements();
        while (en.hasMoreElements()) {
            String item = en.nextElement();
            System.out.println(item);
        }
    }
}

// io.thecodeforge — java tutorial
import java.util.*;

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

        long start = System.nanoTime();
        for (int i = 0; i < list.size(); i++) { list.get(i); }
        long end = System.nanoTime();
        System.out.println("Index loop: " + (end - start) / 1_000_000 + " ms");

        start = System.nanoTime();
        for (Integer val : list) { }
        end = System.nanoTime();
        System.out.println("For-each: " + (end - start) / 1_000_000 + " ms");
    }
}

// io.thecodeforge — java tutorial
import java.util.*;

public class FAQsExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);

        // Best practice: iterate entry set
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // ListIterator from end
        List<String> list = Arrays.asList("X", "Y", "Z");
        ListIterator<String> li = list.listIterator(list.size());
        while (li.hasPrevious()) {
            System.out.println(li.previous());
        }
    }
}