What is the Difference Between Iterator and ListIterator in Java?

Both are used to traverse collections, but ListIterator has additional capabilities for List collections.

1. Iterator (Universal - All Collections)

import java.util.*;

public class IteratorExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");
        list.add("JavaScript");
        
        Iterator iterator = list.iterator();
        
        // Forward traversal only
        System.out.println("Forward traversal:");
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println("  " + element);
            
            // Can remove elements during iteration
            if (element.equals("Python")) {
                iterator.remove(); // Safe removal
                System.out.println("    Removed Python");
            }
        }
        
        System.out.println("After removal: " + list);
        // Output: [Java, C++, JavaScript]
        
        // Cannot add or modify while iterating (except remove)
        // iterator.add() does not exist
        // iterator.set() does not exist
        
        // Works with any Collection (List, Set, Queue)
        Set set = new HashSet<>(list);
        Iterator setIterator = set.iterator();
        System.out.println("Works with Set: " + set);
    }
}

2. ListIterator (List-Specific - More Features)

public class ListIteratorExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        
        ListIterator listIterator = list.listIterator();
        
        // Forward traversal with index
        System.out.println("Forward traversal with indices:");
        while (listIterator.hasNext()) {
            int index = listIterator.nextIndex();
            String element = listIterator.next();
            System.out.println("Index " + index + ": " + element);
        }
        
        // Backward traversal
        System.out.println("
Backward traversal:");
        while (listIterator.hasPrevious()) {
            int index = listIterator.previousIndex();
            String element = listIterator.previous();
            System.out.println("Index " + index + ": " + element);
        }
    }
}

ListIterator - Modify Operations

public class ListIteratorModification {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");
        
        ListIterator lit = list.listIterator();
        
        System.out.println("Original list: " + list);
        
        while (lit.hasNext()) {
            String element = lit.next();
            
            // 1. Set/update current element
            if (element.equals("Banana")) {
                lit.set("Blueberry");
                System.out.println("  Changed Banana to Blueberry");
            }
            
            // 2. Add new element (inserts after current)
            if (element.equals("Cherry")) {
                lit.add("Cranberry");
                System.out.println("  Added Cranberry after Cherry");
            }
            
            // 3. Remove element
            if (element.equals("Date")) {
                lit.remove();
                System.out.println("  Removed Date");
            }
        }
        
        System.out.println("After modifications: " + list);
        // Output: [Apple, Blueberry, Cherry, Cranberry]
    }
}

Position-Based Navigation

public class PositionNavigation {
    public static void main(String[] args) {
        List numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        
        System.out.println("Full list: " + numbers);
        
        // Create ListIterator starting at index 5 (6th element)
        ListIterator lit = numbers.listIterator(5);
        
        System.out.println("
Starting from index 5 (value " + lit.next() + "):");
        System.out.print("Forward: ");
        while (lit.hasNext()) {
            System.out.print(lit.next() + " ");
        }
        // Output: 6 7 8 9 10
        
        // Create iterator from specific position for reverse traversal
        ListIterator reverseLit = numbers.listIterator(numbers.size());
        System.out.println("

Reverse order:");
        while (reverseLit.hasPrevious()) {
            System.out.print(reverseLit.previous() + " ");
        }
        // Output: 10 9 8 7 6 5 4 3 2 1
        
        // Get current positions
        ListIterator lit2 = numbers.listIterator(3);
        System.out.println("

Start at index 3:");
        System.out.println("nextIndex(): " + lit2.nextIndex()); // 3
        System.out.println("next(): " + lit2.next()); // 4
        System.out.println("previousIndex(): " + lit2.previousIndex()); // 3
        System.out.println("previous(): " + lit2.previous()); // 4
    }
}

Fail-Fast vs Fail-Safe

public class FailFastDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        
        // Fail-Fast Iterator
        Iterator it = list.iterator();
        
        System.out.println("Fail-Fast Iterator:");
        while (it.hasNext()) {
            String element = it.next();
            System.out.println("  " + element);
            
            // This would cause ConcurrentModificationException
            // Because we're modifying the list while iterating
            // list.add("D");
            
            // Safe way: use iterator's own remove method
            if (element.equals("B")) {
                it.remove(); // Safe - uses iterator's remove
                System.out.println("    Removed B (safe)");
            }
        }
        
        System.out.println("Final list: " + list);
        
        // Demonstration of ConcurrentModificationException
        List testList = new ArrayList<>();
        testList.add("X");
        testList.add("Y");
        testList.add("Z");
        
        Iterator iterator = testList.iterator();
        try {
            while (iterator.hasNext()) {
                String elem = iterator.next();
                if (elem.equals("Y")) {
                    // testList.remove("Y"); // Would cause ConcurrentModificationException
                    iterator.remove(); // Correct way
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Exception caught: " + e);
        }
    }
}

Comparison Table

When to Use Which?

public class WhenToUse {
    public static void main(String[] args) {
        // Use Iterator when:
        // - Working with any Collection (Set, Queue, etc.)
        // - Need simple forward traversal only
        // - Only need to remove elements
        
        Set set = new HashSet<>();
        set.add("One");
        set.add("Two");
        set.add("Three");
        
        Iterator it = set.iterator();
        while (it.hasNext()) {
            String element = it.next();
            if (element.equals("Two")) {
                it.remove(); // Only remove operation
            }
        }
        System.out.println("Set after removal: " + set);
        
        // Use ListIterator when:
        // - Working with List
        // - Need bidirectional traversal
        // - Need to add, update, or get index positions
        
        List list = new ArrayList<>();
        list.add("First");
        list.add("Second");
        list.add("Third");
        
        // From beginning
        ListIterator lit1 = list.listIterator();
        
        // From specific index
        ListIterator lit2 = list.listIterator(2);
        
        // Example: Replace all occurrences
        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            String element = lit.next();
            if (element.equals("Second")) {
                lit.set("Second (modified)");
            }
        }
        System.out.println("Modified list: " + list);
        
        // Example: Insert elements
        List numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(5);
        
        ListIterator numIt = numbers.listIterator();
        while (numIt.hasNext()) {
            Integer num = numIt.next();
            if (num == 3) {
                numIt.add(2); // Insert before 3? No, after previous element
                // Actually adds after 2, before 3
            }
        }
        System.out.println("After insertion: " + numbers);
    }
}

Master Java collections traversal with Online Learner!