Iterator Interface

The Iterator interface is a fundamental component of Java's collection framework. Unlike Map and Collection interfaces that define storage specifications, Iterator focuses on providing a standardized mechanism for traversing elements within collections.

public interface Iterator<E> {
    // Checks if there are more elements to iterate
    boolean hasNext();
    
    // Retrieves the next element in the iteration
    E next();
    
    // Removes the last element returned by next()
    default void remove() {
        throw new UnsupportedOperationException("remove operation not supported");
    }
    
    // Performs an action on each remaining element
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Why Do We Need the Iterator Interface?

The primary purpose of the Iterator interface is to abstract the traversal mechanism across different collection types. Without this abstraction, developers would need to implement specific traversal logic for each collection type, leading to tightly coupled code.

Consider a scenario without iterators:

// Without iterator - tightly coupled to array structure
for(int index = 0; index < dataArray.length; index++) {
    DataElement element = dataArray[index];
    // Process element
}

This appraoch requires knowledge of the underlying data structure. If the data structure changes (e.g., from array to linked list), the traversal logic must be completely rewritten. The iterator pattern decouples the traversal mechanism from the collection's internal implementation, allowing for more flexible and maintainable code.

Iterable Interface

The Iterable interface represents one of the top-level interfaces in Java's collection hierarchy. Implementing this interface indicates that a class can provide an iterator for its elements. Introduced in JDK 1.5, the Iterable interface defines the contract for objects that can be iterated.

The interface source code:

public interface Iterable<T> {
    // Returns an iterator over the elements in this collection
    Iterator<T> iterator();
    
    // Performs an action for each element in the collection
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        iterator().forEachRemaining(action);
    }
    
    // Creates a spliterator for the elements in this collection
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

The Iterable interface primarily serves to obtain an iterator, with additional methods for enhanced operations. Core collection interfaces like Collection, List, and Set all extend Iterable, enabling their instances to be used in enhanced for-loops.

Why Both Iterator and Iterable? Design Considerations