Iterator

The Iterator pattern is a behavioral design pattern that allows you to traverse elements of a collection (like a list or a set) without exposing the underlying representation. It provides a way to access the elements of an aggregate object sequentially without exposing its underlying structure.

In simpler terms, it allows you to loop through a collection of objects in a standard way without needing to know the details of how the collection is implemented.

Common use cases

1. Collections: Traversing elements in collections like lists, sets, or maps without exposing their internal structure.

2. Tree Structures: Navigating through tree structures, such as DOM trees in web development.

3. Custom Data Structures: Iterating over custom data structures where a standard iteration mechanism is not available.

4. File Systems: Iterating over files and directories in a file system.

5. Database Results: Traversing through rows in a database result set.

6. Aggregated Data: Iterating over aggregated data from multiple sources.

7. Streaming Data: Processing elements in a stream of data, such as log files or network packets.

UML Diagram

+-------------------+      +-------------------+
|   Aggregate       |      |   Iterator        |
+-------------------+      +-------------------+
| +createIterator() |<>----| +next()           |
+-------------------+      | +hasNext()        |
                           +-------------------+
                                  ^
                                  |
                                  |
                           +-------------------+
                           | ConcreteIterator  |
                           +-------------------+
                           | -currentPosition  |
                           +-------------------+
                           | +next()           |
                           | +hasNext()        |
                           +-------------------+
                                  ^
                                  |
                                  |
                           +-------------------+
                           | ConcreteAggregate |
                           +-------------------+
                           | -items            |
                           +-------------------+
                           | +createIterator() |
                           +-------------------+

--- Java Example ---

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

 public interface Iterator<T> {
     boolean hasNext();
     T next();
 }
 //-----------------
 import java.util.List;

 public class ConcreteIterator<T> implements Iterator<T> {
     private List<T> items;
     private int position = 0;

     public ConcreteIterator(List<T> items) {
         this.items = items;
     }

     @Override
     public boolean hasNext() {
         return position < items.size();
     }

     @Override
     public T next() {
         if (this.hasNext()) {
             return items.get(position++);
         }
         return null;
     }
 }

 //-----------------
 public interface Aggregate<T> {
     Iterator<T> createIterator();
 }

 //-----------------
 import java.util.ArrayList;
 import java.util.List;

 public class ConcreteAggregate<T> implements Aggregate<T> {
     private List<T> items = new ArrayList<>();

     public void addItem(T item) {
         items.add(item);
     }

     @Override
     public Iterator<T> createIterator() {
         return new ConcreteIterator<>(items);
     }
 }

 // Client
 public class Main {
     public static void main(String[] args) {
         ConcreteAggregate aggregate = new ConcreteAggregate();
         aggregate.addItem("Item 1");
         aggregate.addItem("Item 2");
         aggregate.addItem("Item 3");

         Iterator iterator = aggregate.createIterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
         }
     }
 }

--- Python Example ---

 from __future__ import annotations
 from typing import List, Any, Iterator as TypingIterator

 # Iterator Interface
 class Iterator:
     def has_next(self) -> bool:
         pass

     def next(self) -> Any:
         pass

 # Concrete Iterator
 class ConcreteIterator(Iterator):
     def __init__(self, items: List[Any]) -> None:
         self._items = items
         self._position = 0

     def has_next(self) -> bool:
         return self._position < len(self._items)

     def next(self) -> Any:
         if self.has_next():
             item = self._items[self._position]
             self._position += 1
             return item
         return None

 # Aggregate Interface
 class Aggregate:
     def create_iterator(self) -> Iterator:
         pass

 # Concrete Aggregate
 class ConcreteAggregate(Aggregate):
     def __init__(self) -> None:
         self._items: List[Any] = []

     def add_item(self, item: Any) -> None:
         self._items.append(item)

     def create_iterator(self) -> Iterator:
         return ConcreteIterator(self._items)

 # Client
 if __name__ == "__main__":
     aggregate = ConcreteAggregate()
     aggregate.add_item("Item 1")
     aggregate.add_item("Item 2")
     aggregate.add_item("Item 3")

     iterator = aggregate.create_iterator()
     while iterator.has_next():
         print(iterator.next())