{"title":"Iterator Design Pattern","description":null,"content":"\n\n\n\n> **DEFINITION**\n>\n> The **Iterator Design Pattern** is a **behavioral pattern** that provides a standard way to **access elements of a collection sequentially without exposing its internal structure**.\n\n\nAt its core, the Iterator pattern is about separating the logic of how you move through a collection from the collection itself. Instead of letting clients directly access internal arrays, lists, or other data structures, the collection provides an iterator object that handles traversal.\n\nIt’s particularly useful in situations where:\n\n- You need to **traverse a collection** (like a list, tree, or graph) in a consistent and flexible way.\n- You want to support **multiple ways to iterate** (e.g., forward, backward, filtering, or skipping elements).\n- You want to **decouple traversal logic from collection structure**, so the client doesn't depend on the internal representation.\n\nLet’s walk through a real-world example to see how we can apply the Iterator Pattern to build a more maintainable, extensible, and standardized approach to traversing collections.\n\n---\n\n# 1. The Problem: Traversing a Playlist\n\nImagine you are building a **music streaming application**. Users can create playlists, add songs, and play them in various ways. A playlist might contain hundreds of songs, and the player needs to iterate through them one by one.\n\nYour first implementation might look like this:\n\n\n```java\nclass Playlist {\n private List songs = new ArrayList<>();\n\n public void addSong(String song) {\n songs.add(song);\n }\n\n public List getSongs() {\n return songs;\n }\n}\n```\n\n```python\nclass Playlist:\n def __init__(self):\n self.songs = []\n \n def add_song(self, song):\n self.songs.append(song)\n \n def get_songs(self):\n return self.songs\n```\n\n```cpp\nclass Playlist {\nprivate:\n vector songs;\n\npublic:\n void addSong(const string& song) {\n songs.push_back(song);\n }\n\n vector getSongs() const {\n return songs;\n }\n};\n```\n\n```go\ntype Playlist struct {\n\tsongs []string\n}\n\nfunc (p *Playlist) AddSong(song string) {\n\tp.songs = append(p.songs, song)\n}\n\nfunc (p *Playlist) GetSongs() []string {\n\treturn p.songs\n}\n```\n\n```csharp\nclass Playlist\n{\n private List songs = new List();\n\n public void AddSong(string song)\n {\n songs.Add(song);\n }\n\n public List GetSongs()\n {\n return songs;\n }\n}\n```\n\n```typescript\nclass Playlist {\n private songs: string[] = [];\n\n addSong(song: string): void {\n this.songs.push(song);\n }\n\n getSongs(): string[] {\n return this.songs;\n }\n}\n```\n\n\nAnd your music player might use it like this:\n\n\n```java\nclass MusicPlayer {\n public void playAll(Playlist playlist) {\n for (String song : playlist.getSongs()) {\n System.out.println(\"Playing: \" + song);\n }\n }\n}\n```\n\n```python\nclass MusicPlayer:\n def play_all(self, playlist):\n for song in playlist.get_songs():\n print(f\"Playing: {song}\")\n```\n\n```cpp\nclass MusicPlayer {\npublic:\n void playAll(const Playlist& playlist) {\n vector songs = playlist.getSongs();\n for (const string& song : songs) {\n cout << \"Playing: \" << song << endl;\n }\n }\n};\n```\n\n```go\ntype MusicPlayer struct{}\n\nfunc (m MusicPlayer) PlayAll(playlist Playlist) {\n\tfor _, song := range playlist.GetSongs() {\n\t\tfmt.Println(\"Playing: \" + song)\n\t}\n}\n```\n\n```csharp\nclass MusicPlayer\n{\n public void PlayAll(Playlist playlist)\n {\n foreach (string song in playlist.GetSongs())\n {\n Console.WriteLine($\"Playing: {song}\");\n }\n }\n}\n```\n\n```typescript\nclass MusicPlayer {\n playAll(playlist: Playlist): void {\n for (const song of playlist.getSongs()) {\n console.log(\"Playing: \" + song);\n }\n }\n}\n```\n\n\nThis looks clean enough. The player gets the list of songs and iterates through them. What could go wrong?\n\n### Why This Becomes a Problem\n\nAs the application grows, several issues emerge:\n\n#### 1. Breaks Encapsulation\n\nBy returning the internal list, you allow clients to do more than just read. They can add songs, remove songs, clear the list, or even replace it entirely. Nothing prevents a client from calling `playlist.getSongs().clear()` and wiping out the entire playlist.\n\n\n```java\n// This should not be possible, but it is\nplaylist.getSongs().add(\"Unauthorized Song\");\nplaylist.getSongs().remove(0);\n```\n\n\n#### 2. Tightly Couples Client to I**mplementation**\n\nYour player assumes the playlist uses a `List`. What if you decide to change the internal structure? Perhaps you want to store songs in a database and load them lazily. Or maybe you want to use a `Set` to prevent duplicates. \n\nEvery change to the internal structure ripples through all client code.\n\n#### 3. Limited Traversal Options\n\nWhat if you need to play songs in reverse order? Or shuffle them? Or skip songs that the user has marked as disliked? \n\nEach of these requires writing new loop logic in the client. The playlist has no control over how its contents are accessed.\n\n#### 4. **Testing becomes difficult**\n\nIf your player directly accesses the list, testing the player in isolation becomes harder. You cannot easily mock or stub the playlist's behavior.\n\n### What We Really Need\n\nWe need a way for clients to traverse the playlist that:\n\n- Does not expose the internal data structure\n- Provides a consistent interface regardless of how songs are stored\n- Allows the playlist to control how iteration happens\n- Supports different traversal strategies without modifying client code\n\nThis is exactly what the **Iterator Pattern** provides.\n\n---\n\n# 2. Understanding the Iterator Pattern\n\n> The **Iterator Pattern** defines a separate object, the **iterator**, that encapsulates the details of traversing a collection. Instead of exposing its internal structure, the collection provides an iterator that clients use to access elements sequentially.\n\nTwo characteristics define the pattern:\n\n1. **Separation of traversal from storage.** The collection knows how to store elements. The iterator knows how to walk through them. These two concerns live in separate classes, so you can change one without affecting the other.\n2. **Multiple independent traversals.** Each call to `createIterator()` returns a new, independent iterator with its own position. Multiple clients can traverse the same collection simultaneously without interfering with each other.\n\nThis separation means you can change how elements are stored without affecting how they are traversed, and vice versa.\n\n\n> **Real-World Analogy**\n>\n> Consider a TV remote control. When you press the \"next channel\" button, you do not need to know how the TV internally organizes its channel list. Maybe it is stored as an array, a linked list, or fetched from a satellite signal. \n>\n> The remote provides a simple interface: next channel, previous channel. The complexity of channel management is hidden behind that interface.\n>\n> The Iterator pattern works the same way. The iterator is like the remote control, providing a simple interface to move through a collection without exposing how that collection is structured internally.\n\n\n---\n\n## Class Diagram\n\nThe Iterator pattern involves four key components:\n\n\n```mermaid\nclassDiagram\n class Iterator {\n <>\n +hasNext(): boolean\n +next(): T\n }\n\n class ConcreteIterator {\n -collection\n -index\n +hasNext(): boolean\n +next(): T\n }\n\n class IterableCollection {\n <>\n +createIterator(): Iterator\n }\n\n class ConcreteCollection {\n -elements\n +createIterator(): Iterator\n }\n\n Iterator <|.. ConcreteIterator\n IterableCollection <|.. ConcreteCollection\n ConcreteCollection ..> ConcreteIterator : creates\n ConcreteIterator --> ConcreteCollection : traverses\n\n style Iterator fill:#00ceff,stroke:#000,color:#000\n style ConcreteIterator fill:#ffa94d,stroke:#000,color:#000\n style IterableCollection fill:#00ceff,stroke:#000,color:#000\n style ConcreteCollection fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n#### 1. Iterator (interface)\n\nDeclares the operations required to traverse a collection. At minimum, this includes `hasNext()` to check if more elements exist, and `next()` to retrieve the next element.\n\n#### 2. ConcreteIterator\n\nImplements the Iterator interface for a specific collection. It maintains the current position within the collection and knows how to move to the next element.\n\n#### 3. IterableCollection (interface)\n\nDeclares a method for creating an iterator. Any class implementing this interface promises it can be iterated.\n\n#### 4. ConcreteCollection\n\nImplements the IterableCollection interface. It stores elements and returns an appropriate iterator when asked.\n\n\n> **Why a Separate Iterator Object?**\n>\n> You might wonder why we need a separate iterator object. Why not just add `hasNext()` and `next()` methods directly to the collection?\n>\n> The answer lies in supporting multiple simultaneous traversals. If the collection itself tracks the current position, you can only have one traversal at a time. But with separate iterator objects, you can have multiple iterators traversing the same collection independently.\n>\n> This becomes important in multi-threaded applications or when you need to compare elements at different positions in the same collection.\n\n\n---\n\n# 3. How It Works\n\nThe Iterator workflow has five steps:\n\n\n```mermaid\nsequenceDiagram\n participant Client\n participant Playlist as Playlist\n participant Iterator as PlaylistIterator\n\n Client->>Playlist: createIterator()\n Playlist->>Iterator: new PlaylistIterator(this)\n Playlist-->>Client: iterator\n\n loop while hasNext()\n Client->>Iterator: hasNext()\n Iterator-->>Client: true\n Client->>Iterator: next()\n Iterator->>Playlist: getSongAt(index)\n Playlist-->>Iterator: song\n Iterator-->>Client: \"Shape of You\"\n end\n\n Client->>Iterator: hasNext()\n Iterator-->>Client: false\n\n Note over Client: Traversal complete.
Client never accessed the
internal list directly.\n```\n\n\n**Step 1:** The client asks the collection for an iterator by calling `createIterator()`.\n\n**Step 2:** The collection creates a new iterator object, passing itself (or its data) to the iterator's constructor.\n\n**Step 3:** The iterator initializes its internal position to the beginning of the collection.\n\n**Step 4:** The client uses the iterator in a loop: call `hasNext()` to check for more elements, then `next()` to get the current element and advance.\n\n**Step 5:** When `hasNext()` returns false, traversal is complete. The client can discard the iterator, or the collection can create a new one for another traversal.\n\n---\n\n# 4. Implementing the Iterator Pattern\n\nLet us refactor our music playlist using the Iterator pattern. We will build the implementation step by step: define the interfaces, implement the collection, implement the iterator, and wire them together.\n\n### Step 1: Define the Iterator Interface\n\nThis interface declares the standard operations for traversing any collection:\n\n\n```java\ninterface Iterator {\n boolean hasNext();\n T next();\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass Iterator(ABC):\n @abstractmethod\n def has_next(self) -> bool:\n pass\n\n @abstractmethod\n def next(self):\n pass\n```\n\n```cpp\ntemplate\nclass Iterator {\npublic:\n virtual ~Iterator() {}\n virtual bool hasNext() = 0;\n virtual T next() = 0;\n};\n```\n\n```go\ntype Iterator[T any] interface {\n\tHasNext() bool\n\tNext() T\n}\n```\n\n```csharp\ninterface IIterator\n{\n bool HasNext();\n T Next();\n}\n```\n\n```typescript\ninterface Iterator {\n hasNext(): boolean;\n next(): T;\n}\n```\n\n\nThe interface is generic (where the language supports it), allowing it to work with any element type. Two methods are sufficient for basic iteration: \n\n- `hasNext()` returns true if there are more elements to iterate\n- `next()` returns the current element and advances to the next position\n\n\n> **NOTE**\n>\n> Some iterator interfaces include additional methods like `remove()`, `reset()`, or `current()`. We are keeping it minimal here. You can always extend the interface based on your needs, but starting simple reduces complexity.\n\n\n### Step 2: Define the IterableCollection Interface\n\nThis interface ensures that any collection can provide an iterator:\n\n\n```java\ninterface IterableCollection {\n Iterator createIterator();\n}\n```\n\n```python\nclass IterableCollection(ABC):\n @abstractmethod\n def create_iterator(self):\n pass\n```\n\n```cpp\ntemplate\nclass IterableCollection {\npublic:\n virtual ~IterableCollection() {}\n virtual Iterator* createIterator() = 0;\n};\n```\n\n```go\ntype IterableCollection[T any] interface {\n\tCreateIterator() Iterator[T]\n}\n```\n\n```csharp\ninterface IIterableCollection\n{\n IIterator CreateIterator();\n}\n```\n\n```typescript\ninterface IterableCollection {\n createIterator(): Iterator;\n}\n```\n\n\nAny class implementing this interface promises to provide an iterator for traversing its elements.\n\n### Step 3: Implement the Concrete Collection\n\nNow we implement the Playlist class. Notice that it no longer exposes its internal list. Instead, it provides controlled access methods that the iterator will use:\n\n\n```java\nclass Playlist implements IterableCollection {\n private final List songs = new ArrayList<>();\n\n public void addSong(String song) {\n songs.add(song);\n }\n\n public String getSongAt(int index) {\n return songs.get(index);\n }\n\n public int getSize() {\n return songs.size();\n }\n\n @Override\n public Iterator createIterator() {\n return new PlaylistIterator(this);\n }\n}\n```\n\n```python\nclass Playlist(IterableCollection):\n def __init__(self):\n self.songs = []\n \n def add_song(self, song):\n self.songs.append(song)\n \n def get_song_at(self, index):\n return self.songs[index]\n \n def get_size(self):\n return len(self.songs)\n \n def create_iterator(self):\n return PlaylistIterator(self)\n```\n\n```cpp\nclass Playlist : public IterableCollection {\nprivate:\n vector songs;\n\npublic:\n void addSong(const string& song) {\n songs.push_back(song);\n }\n\n string getSongAt(int index) const {\n return songs[index];\n }\n\n int getSize() const {\n return songs.size();\n }\n\n Iterator* createIterator() override {\n return new PlaylistIterator(this);\n }\n};\n```\n\n```go\ntype Playlist struct {\n\tsongs []string\n}\n\nfunc (p *Playlist) AddSong(song string) {\n\tp.songs = append(p.songs, song)\n}\n\nfunc (p *Playlist) GetSongAt(index int) string {\n\treturn p.songs[index]\n}\n\nfunc (p *Playlist) GetSize() int {\n\treturn len(p.songs)\n}\n\nfunc (p *Playlist) CreateIterator() Iterator[string] {\n\treturn NewPlaylistIterator(p)\n}\n```\n\n```csharp\nclass Playlist : IIterableCollection\n{\n private List songs = new List();\n\n public void AddSong(string song)\n {\n songs.Add(song);\n }\n\n public string GetSongAt(int index)\n {\n return songs[index];\n }\n\n public int GetSize()\n {\n return songs.Count;\n }\n\n public IIterator CreateIterator()\n {\n return new PlaylistIterator(this);\n }\n}\n```\n\n```typescript\nclass Playlist implements IterableCollection {\n private readonly songs: string[] = [];\n\n addSong(song: string): void {\n this.songs.push(song);\n }\n\n getSongAt(index: number): string {\n return this.songs[index];\n }\n\n getSize(): number {\n return this.songs.length;\n }\n\n createIterator(): Iterator {\n return new PlaylistIterator(this);\n }\n}\n```\n\n\nThe key change: `getSongs()` is gone. Clients cannot get the raw list anymore. Instead, `getSongAt()` and `getSize()` provide the minimum access the iterator needs, while keeping the internal structure private.\n\n### Step 4: Implement the Concrete Iterator\n\nThe iterator maintains its position and knows how to traverse the playlist:\n\n\n```java\nclass PlaylistIterator implements Iterator {\n private final Playlist playlist;\n private int index = 0;\n\n public PlaylistIterator(Playlist playlist) {\n this.playlist = playlist;\n }\n\n @Override\n public boolean hasNext() {\n return index < playlist.getSize();\n }\n\n @Override\n public String next() {\n return playlist.getSongAt(index++);\n }\n}\n```\n\n```python\nclass PlaylistIterator(Iterator):\n def __init__(self, playlist):\n self.playlist = playlist\n self.index = 0\n \n def has_next(self):\n return self.index < self.playlist.get_size()\n \n def next(self):\n song = self.playlist.get_song_at(self.index)\n self.index += 1\n return song\n```\n\n```cpp\nclass PlaylistIterator : public Iterator {\nprivate:\n PlaylistIteratorPattern* playlist;\n int index;\n\npublic:\n PlaylistIterator(PlaylistIteratorPattern* pl);\n \n bool hasNext() override {\n return index < playlist->getSize();\n }\n \n string next() override {\n string song = playlist->getSongAt(index);\n index++;\n return song;\n }\n};\n```\n\n```go\ntype PlaylistIterator struct {\n\tplaylist *Playlist\n\tindex int\n}\n\nfunc NewPlaylistIterator(playlist *Playlist) *PlaylistIterator {\n\treturn &PlaylistIterator{playlist: playlist}\n}\n\nfunc (it *PlaylistIterator) HasNext() bool {\n\treturn it.index < it.playlist.GetSize()\n}\n\nfunc (it *PlaylistIterator) Next() string {\n\tsong := it.playlist.GetSongAt(it.index)\n\tit.index++\n\treturn song\n}\n```\n\n```csharp\nclass PlaylistIterator : IIterator\n{\n private PlaylistIteratorPattern playlist;\n private int index = 0;\n\n public PlaylistIterator(PlaylistIteratorPattern playlist)\n {\n this.playlist = playlist;\n }\n\n public bool HasNext()\n {\n return index < playlist.GetSize();\n }\n\n public string Next()\n {\n string song = playlist.GetSongAt(index);\n index++;\n return song;\n }\n}\n```\n\n```typescript\nclass PlaylistIterator implements Iterator {\n private readonly playlist: Playlist;\n private index: number = 0;\n\n constructor(playlist: Playlist) {\n this.playlist = playlist;\n }\n\n hasNext(): boolean {\n return this.index < this.playlist.getSize();\n }\n\n next(): string {\n return this.playlist.getSongAt(this.index++);\n }\n}\n```\n\n\nThe iterator is simple by design. It holds a reference to the playlist and an index that starts at zero. Each call to `next()` returns the current song and advances the index. Each call to `hasNext()` checks whether the index has reached the end.\n\n### Step 5: Using the Iterator (Client Code)\n\nThe client can now iterate through a playlist without knowing how it's implemented internally.\n\n\n```java\npublic class MusicPlayer {\n public static void main(String[] args) {\n Playlist playlist = new Playlist();\n playlist.addSong(\"Shape of You\");\n playlist.addSong(\"Bohemian Rhapsody\");\n playlist.addSong(\"Blinding Lights\");\n\n Iterator iterator = playlist.createIterator();\n\n System.out.println(\"Now Playing:\");\n while (iterator.hasNext()) {\n System.out.println(\" 🎵 \" + iterator.next());\n }\n }\n}\n```\n\n```python\ndef music_player_demo():\n playlist = PlaylistIteratorPattern()\n playlist.add_song(\"Shape of You\")\n playlist.add_song(\"Bohemian Rhapsody\")\n playlist.add_song(\"Blinding Lights\")\n \n iterator = playlist.create_iterator()\n \n print(\"Now Playing:\")\n while iterator.has_next():\n print(f\" 🎵 {iterator.next()}\")\n\nif __name__ == \"__main__\":\n\n music_player_demo()\n```\n\n```cpp\nvoid musicPlayerDemo() {\n PlaylistIteratorPattern playlist;\n playlist.addSong(\"Shape of You\");\n playlist.addSong(\"Bohemian Rhapsody\");\n playlist.addSong(\"Blinding Lights\");\n\n Iterator* iterator = playlist.createIterator();\n\n cout << \"Now Playing:\" << endl;\n while (iterator->hasNext()) {\n cout << \" 🎵 \" << iterator->next() << endl;\n }\n\n delete iterator;\n}\n\nint main() {\n musicPlayerDemo();\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\nfunc musicPlayerDemo() {\n\tplaylist := PlaylistIteratorPattern{}\n\tplaylist.addSong(\"Shape of You\")\n\tplaylist.addSong(\"Bohemian Rhapsody\")\n\tplaylist.addSong(\"Blinding Lights\")\n\n\titerator := playlist.createIterator()\n\n\tfmt.Println(\"Now Playing:\")\n\tfor iterator.hasNext() {\n\t\tfmt.Println(\" 🎵 \", iterator.next())\n\t}\n}\n\nfunc main() {\n\tmusicPlayerDemo()\n}\n```\n\n```csharp\npublic class Program\n{\n public static void Main(string[] args)\n {\n PlaylistIteratorPattern playlist = new PlaylistIteratorPattern();\n playlist.AddSong(\"Shape of You\");\n playlist.AddSong(\"Bohemian Rhapsody\");\n playlist.AddSong(\"Blinding Lights\");\n\n IIterator iterator = playlist.CreateIterator();\n\n Console.WriteLine(\"Now Playing:\");\n while (iterator.HasNext())\n {\n Console.WriteLine($\" 🎵 {iterator.Next()}\");\n }\n }\n}\n```\n\n```typescript\nclass MusicPlayer {\n static main(): void {\n const playlist = new Playlist();\n playlist.addSong(\"Shape of You\");\n playlist.addSong(\"Bohemian Rhapsody\");\n playlist.addSong(\"Blinding Lights\");\n\n const iterator: Iterator = playlist.createIterator();\n\n console.log(\"Now Playing:\");\n while (iterator.hasNext()) {\n console.log(\" 🎵 \" + iterator.next());\n }\n }\n}\n```\n\n\n#### Expected Output:\n\n\n```shell\nNow Playing:\n🎵 Shape of You\n🎵 Bohemian Rhapsody\n🎵 Blinding Lights\n```\n\n\nThe client code is clean and focused. It does not know or care whether the playlist uses an ArrayList, LinkedList, or any other structure internally.\n\n### What We Gained\n\nLet us evaluate what the Iterator Pattern has given us:\n\n#### **Encapsulation is preserved**\n\nThe internal list is no longer exposed. Clients cannot accidentally (or intentionally) modify the playlist's contents through the iterator. The playlist maintains full control over its data.\n\n#### **Implementation independence**\n\nThe client code works with the Iterator interface. If we later change the playlist to use a LinkedList, a database, or a streaming buffer, the client code remains unchanged. We only need to update the iterator implementation.\n\n#### **Single Responsibility Principle**\n\nThe Playlist class focuses on managing songs. The PlaylistIterator class focuses on traversal logic. Each class has one reason to change.\n\n#### **Multiple simultaneous traversals**\n\nEach call to `createIterator()` returns a new, independent iterator. Multiple parts of your application can traverse the same playlist simultaneously without interfering with each other.\n\n#### **Foundation for extensions**\n\nWe can now easily add new types of iterators (reverse, shuffled, filtered) without modifying the Playlist class or existing client code.\n\n---\n\n# 5. Extending the Design\n\nOne of the most powerful aspects of the Iterator pattern is how easily you can add new traversal behaviors without modifying the collection or client code.\n\nSuppose tomorrow the product team wants two new features: play songs in reverse order, and play songs in a random shuffle. Without the Iterator pattern, you would add methods like `playReverse()` and `playShuffle()` to the player, each with its own loop logic. With the pattern, you just create new iterator classes.\n\n### ReversePlaylistIterator\n\n\n```java\nclass ReversePlaylistIterator implements Iterator {\n private final Playlist playlist;\n private int index;\n\n public ReversePlaylistIterator(Playlist playlist) {\n this.playlist = playlist;\n this.index = playlist.getSize() - 1;\n }\n\n @Override\n public boolean hasNext() {\n return index >= 0;\n }\n\n @Override\n public String next() {\n return playlist.getSongAt(index--);\n }\n}\n```\n\n```python\nclass ReversePlaylistIterator(Iterator):\n def __init__(self, playlist):\n self._playlist = playlist\n self._index = playlist.get_size() - 1\n\n def has_next(self):\n return self._index >= 0\n\n def next(self):\n song = self._playlist.get_song_at(self._index)\n self._index -= 1\n return song\n```\n\n```cpp\nclass ReversePlaylistIterator : public Iterator {\nprivate:\n Playlist* playlist;\n int index;\n\npublic:\n ReversePlaylistIterator(Playlist* pl)\n : playlist(pl), index(pl->getSize() - 1) {}\n\n bool hasNext() override {\n return index >= 0;\n }\n\n string next() override {\n string song = playlist->getSongAt(index);\n index--;\n return song;\n }\n};\n```\n\n```go\ntype ReversePlaylistIterator struct {\n\tplaylist Playlist\n\tindex int\n}\n\nfunc NewReversePlaylistIterator(playlist Playlist) *ReversePlaylistIterator {\n\treturn &ReversePlaylistIterator{\n\t\tplaylist: playlist,\n\t\tindex: playlist.GetSize() - 1,\n\t}\n}\n\nfunc (r *ReversePlaylistIterator) HasNext() bool {\n\treturn r.index >= 0\n}\n\nfunc (r *ReversePlaylistIterator) Next() string {\n\tsong := r.playlist.GetSongAt(r.index)\n\tr.index--\n\treturn song\n}\n```\n\n```csharp\nclass ReversePlaylistIterator : IIterator\n{\n private Playlist playlist;\n private int index;\n\n public ReversePlaylistIterator(Playlist playlist)\n {\n this.playlist = playlist;\n this.index = playlist.GetSize() - 1;\n }\n\n public bool HasNext()\n {\n return index >= 0;\n }\n\n public string Next()\n {\n string song = playlist.GetSongAt(index);\n index--;\n return song;\n }\n}\n```\n\n```typescript\nclass ReversePlaylistIterator implements Iterator {\n private readonly playlist: Playlist;\n private index: number;\n\n constructor(playlist: Playlist) {\n this.playlist = playlist;\n this.index = playlist.getSize() - 1;\n }\n\n hasNext(): boolean {\n return this.index >= 0;\n }\n\n next(): string {\n return this.playlist.getSongAt(this.index--);\n }\n}\n```\n\n\n### ShufflePlaylistIterator\n\n\n```java\nclass ShufflePlaylistIterator implements Iterator {\n private final Playlist playlist;\n private final List shuffledIndices;\n private int position = 0;\n\n public ShufflePlaylistIterator(Playlist playlist) {\n this.playlist = playlist;\n this.shuffledIndices = new ArrayList<>();\n for (int i = 0; i < playlist.getSize(); i++) {\n shuffledIndices.add(i);\n }\n Collections.shuffle(shuffledIndices);\n }\n\n @Override\n public boolean hasNext() {\n return position < shuffledIndices.size();\n }\n\n @Override\n public String next() {\n int index = shuffledIndices.get(position++);\n return playlist.getSongAt(index);\n }\n}\n```\n\n```python\nimport random\n\nclass ShufflePlaylistIterator(Iterator):\n def __init__(self, playlist):\n self._playlist = playlist\n self._indices = list(range(playlist.get_size()))\n random.shuffle(self._indices)\n self._position = 0\n\n def has_next(self):\n return self._position < len(self._indices)\n\n def next(self):\n index = self._indices[self._position]\n self._position += 1\n return self._playlist.get_song_at(index)\n```\n\n```cpp\nclass ShufflePlaylistIterator : public Iterator {\nprivate:\n Playlist* playlist;\n vector shuffledIndices;\n int position;\n\npublic:\n ShufflePlaylistIterator(Playlist* pl) : playlist(pl), position(0) {\n for (int i = 0; i < pl->getSize(); i++) {\n shuffledIndices.push_back(i);\n }\n auto rng = default_random_engine{};\n shuffle(shuffledIndices.begin(), shuffledIndices.end(), rng);\n }\n\n bool hasNext() override {\n return position < shuffledIndices.size();\n }\n\n string next() override {\n int index = shuffledIndices[position++];\n return playlist->getSongAt(index);\n }\n};\n```\n\n```go\ntype ShufflePlaylistIterator struct {\n\tplaylist *Playlist\n\tshuffledIndices []int\n\tposition int\n}\n\nfunc NewShufflePlaylistIterator(playlist *Playlist) *ShufflePlaylistIterator {\n\tit := &ShufflePlaylistIterator{\n\t\tplaylist: playlist,\n\t\tposition: 0,\n\t}\n\tfor i := 0; i < playlist.GetSize(); i++ {\n\t\tit.shuffledIndices = append(it.shuffledIndices, i)\n\t}\n\trand.Shuffle(len(it.shuffledIndices), func(i, j int) {\n\t\tit.shuffledIndices[i], it.shuffledIndices[j] = it.shuffledIndices[j], it.shuffledIndices[i]\n\t})\n\treturn it\n}\n\nfunc (s *ShufflePlaylistIterator) HasNext() bool {\n\treturn s.position < len(s.shuffledIndices)\n}\n\nfunc (s *ShufflePlaylistIterator) Next() string {\n\tindex := s.shuffledIndices[s.position]\n\ts.position++\n\treturn s.playlist.GetSongAt(index)\n}\n```\n\n```csharp\nclass ShufflePlaylistIterator : IIterator\n{\n private Playlist playlist;\n private List shuffledIndices;\n private int position = 0;\n\n public ShufflePlaylistIterator(Playlist playlist)\n {\n this.playlist = playlist;\n shuffledIndices = Enumerable.Range(0, playlist.GetSize()).ToList();\n Random rng = new Random();\n shuffledIndices = shuffledIndices.OrderBy(_ => rng.Next()).ToList();\n }\n\n public bool HasNext()\n {\n return position < shuffledIndices.Count;\n }\n\n public string Next()\n {\n int index = shuffledIndices[position++];\n return playlist.GetSongAt(index);\n }\n}\n```\n\n```typescript\nclass ShufflePlaylistIterator implements Iterator {\n private readonly playlist: Playlist;\n private readonly shuffledIndices: number[];\n private position: number = 0;\n\n constructor(playlist: Playlist) {\n this.playlist = playlist;\n this.shuffledIndices = Array.from(\n { length: playlist.getSize() },\n (_, i) => i\n );\n for (let i = this.shuffledIndices.length - 1; i > 0; i--) {\n const j = Math.floor(Math.random() * (i + 1));\n [this.shuffledIndices[i], this.shuffledIndices[j]] =\n [this.shuffledIndices[j], this.shuffledIndices[i]];\n }\n }\n\n hasNext(): boolean {\n return this.position < this.shuffledIndices.length;\n }\n\n next(): string {\n const index = this.shuffledIndices[this.position++];\n return this.playlist.getSongAt(index);\n }\n}\n```\n\n\n---\n\n# 6. Practical Example: Notification System\n\nLet us work through a second example to reinforce the pattern in a different domain. We are building a notification system where a `NotificationCenter` stores notifications of different types: email, SMS, and push. We need iterators that can traverse all notifications, filter by type, and show only unread notifications.\n\n\n```mermaid\nclassDiagram\n class NotificationIterator {\n <>\n +hasNext(): boolean\n +next(): Notification\n }\n\n class NotificationCollection {\n <>\n +createIterator(): NotificationIterator\n }\n\n class NotificationCenter {\n -notifications: List\n +add(notification)\n +createIterator(): NotificationIterator\n +createFilteredIterator(type): NotificationIterator\n +createUnreadIterator(): NotificationIterator\n }\n\n class AllNotificationsIterator {\n -center\n -index\n }\n\n class FilteredIterator {\n -center\n -type\n -index\n }\n\n class UnreadIterator {\n -center\n -index\n }\n\n NotificationIterator <|.. AllNotificationsIterator\n NotificationIterator <|.. FilteredIterator\n NotificationIterator <|.. UnreadIterator\n NotificationCollection <|.. NotificationCenter\n NotificationCenter ..> AllNotificationsIterator : creates\n NotificationCenter ..> FilteredIterator : creates\n NotificationCenter ..> UnreadIterator : creates\n\n style NotificationIterator fill:#00ceff,stroke:#000,color:#000\n style NotificationCollection fill:#00ceff,stroke:#000,color:#000\n style NotificationCenter fill:#38d9a9,stroke:#000,color:#000\n style AllNotificationsIterator fill:#ffa94d,stroke:#000,color:#000\n style FilteredIterator fill:#ffa94d,stroke:#000,color:#000\n style UnreadIterator fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThis is where the pattern really shines: three different ways to traverse the same collection, all behind the same interface. The client code is identical for each traversal mode, only the iterator creation changes.\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.List;\n\nclass Notification {\n private final String message;\n private final String type; // \"EMAIL\", \"SMS\", \"PUSH\"\n private boolean read;\n\n public Notification(String message, String type) {\n this.message = message;\n this.type = type;\n this.read = false;\n }\n\n public String getMessage() { return message; }\n public String getType() { return type; }\n public boolean isRead() { return read; }\n public void markRead() { this.read = true; }\n\n @Override\n public String toString() {\n return \"[\" + type + \"] \" + message + (read ? \" (read)\" : \" (unread)\");\n }\n}\n\ninterface NotificationIterator {\n boolean hasNext();\n Notification next();\n}\n\nclass NotificationCenter {\n private final List notifications = new ArrayList<>();\n\n public void add(Notification notification) {\n notifications.add(notification);\n }\n\n public Notification getAt(int index) {\n return notifications.get(index);\n }\n\n public int getSize() {\n return notifications.size();\n }\n\n public NotificationIterator createIterator() {\n return new AllNotificationsIterator(this);\n }\n\n public NotificationIterator createFilteredIterator(String type) {\n return new FilteredIterator(this, type);\n }\n\n public NotificationIterator createUnreadIterator() {\n return new UnreadIterator(this);\n }\n}\n\nclass AllNotificationsIterator implements NotificationIterator {\n private final NotificationCenter center;\n private int index = 0;\n\n public AllNotificationsIterator(NotificationCenter center) {\n this.center = center;\n }\n\n @Override\n public boolean hasNext() {\n return index < center.getSize();\n }\n\n @Override\n public Notification next() {\n return center.getAt(index++);\n }\n}\n\nclass FilteredIterator implements NotificationIterator {\n private final NotificationCenter center;\n private final String type;\n private int index = 0;\n\n public FilteredIterator(NotificationCenter center, String type) {\n this.center = center;\n this.type = type;\n advanceToNext();\n }\n\n private void advanceToNext() {\n while (index < center.getSize()\n && !center.getAt(index).getType().equals(type)) {\n index++;\n }\n }\n\n @Override\n public boolean hasNext() {\n return index < center.getSize();\n }\n\n @Override\n public Notification next() {\n Notification notification = center.getAt(index);\n index++;\n advanceToNext();\n return notification;\n }\n}\n\nclass UnreadIterator implements NotificationIterator {\n private final NotificationCenter center;\n private int index = 0;\n\n public UnreadIterator(NotificationCenter center) {\n this.center = center;\n advanceToNext();\n }\n\n private void advanceToNext() {\n while (index < center.getSize() && center.getAt(index).isRead()) {\n index++;\n }\n }\n\n @Override\n public boolean hasNext() {\n return index < center.getSize();\n }\n\n @Override\n public Notification next() {\n Notification notification = center.getAt(index);\n index++;\n advanceToNext();\n return notification;\n }\n}\n\npublic class NotificationDemo {\n public static void main(String[] args) {\n NotificationCenter center = new NotificationCenter();\n center.add(new Notification(\"Your order shipped\", \"EMAIL\"));\n center.add(new Notification(\"Flash sale today!\", \"PUSH\"));\n center.add(new Notification(\"Verify your number\", \"SMS\"));\n center.add(new Notification(\"Invoice ready\", \"EMAIL\"));\n center.add(new Notification(\"New login detected\", \"PUSH\"));\n\n // Mark some as read\n center.getAt(0).markRead();\n center.getAt(2).markRead();\n\n System.out.println(\"--- All Notifications ---\");\n NotificationIterator all = center.createIterator();\n while (all.hasNext()) {\n System.out.println(\" \" + all.next());\n }\n\n System.out.println(\"\\n--- Email Only ---\");\n NotificationIterator emails = center.createFilteredIterator(\"EMAIL\");\n while (emails.hasNext()) {\n System.out.println(\" \" + emails.next());\n }\n\n System.out.println(\"\\n--- Unread Only ---\");\n NotificationIterator unread = center.createUnreadIterator();\n while (unread.hasNext()) {\n System.out.println(\" \" + unread.next());\n }\n }\n}\n```\n\n```python\nclass Notification:\n def __init__(self, message, notification_type):\n self.message = message\n self.type = notification_type\n self.read = False\n\n def mark_read(self):\n self.read = True\n\n def __str__(self):\n status = \"read\" if self.read else \"unread\"\n return f\"[{self.type}] {self.message} ({status})\"\n\nclass NotificationCenter:\n def __init__(self):\n self._notifications = []\n\n def add(self, notification):\n self._notifications.append(notification)\n\n def get_at(self, index):\n return self._notifications[index]\n\n def get_size(self):\n return len(self._notifications)\n\n def create_iterator(self):\n return AllNotificationsIterator(self)\n\n def create_filtered_iterator(self, notification_type):\n return FilteredIterator(self, notification_type)\n\n def create_unread_iterator(self):\n return UnreadIterator(self)\n\nclass AllNotificationsIterator:\n def __init__(self, center):\n self._center = center\n self._index = 0\n\n def has_next(self):\n return self._index < self._center.get_size()\n\n def next(self):\n notification = self._center.get_at(self._index)\n self._index += 1\n return notification\n\nclass FilteredIterator:\n def __init__(self, center, notification_type):\n self._center = center\n self._type = notification_type\n self._index = 0\n self._advance_to_next()\n\n def _advance_to_next(self):\n while (self._index < self._center.get_size()\n and self._center.get_at(self._index).type != self._type):\n self._index += 1\n\n def has_next(self):\n return self._index < self._center.get_size()\n\n def next(self):\n notification = self._center.get_at(self._index)\n self._index += 1\n self._advance_to_next()\n return notification\n\nclass UnreadIterator:\n def __init__(self, center):\n self._center = center\n self._index = 0\n self._advance_to_next()\n\n def _advance_to_next(self):\n while (self._index < self._center.get_size()\n and self._center.get_at(self._index).read):\n self._index += 1\n\n def has_next(self):\n return self._index < self._center.get_size()\n\n def next(self):\n notification = self._center.get_at(self._index)\n self._index += 1\n self._advance_to_next()\n return notification\n\ncenter = NotificationCenter()\ncenter.add(Notification(\"Your order shipped\", \"EMAIL\"))\ncenter.add(Notification(\"Flash sale today!\", \"PUSH\"))\ncenter.add(Notification(\"Verify your number\", \"SMS\"))\ncenter.add(Notification(\"Invoice ready\", \"EMAIL\"))\ncenter.add(Notification(\"New login detected\", \"PUSH\"))\n\ncenter.get_at(0).mark_read()\ncenter.get_at(2).mark_read()\n\nprint(\"--- All Notifications ---\")\nit = center.create_iterator()\nwhile it.has_next():\n print(f\" {it.next()}\")\n\nprint(\"\\n--- Email Only ---\")\nit = center.create_filtered_iterator(\"EMAIL\")\nwhile it.has_next():\n print(f\" {it.next()}\")\n\nprint(\"\\n--- Unread Only ---\")\nit = center.create_unread_iterator()\nwhile it.has_next():\n print(f\" {it.next()}\")\n```\n\n```cpp\n#include \n#include \n#include \nusing namespace std;\n\nclass Notification {\nprivate:\n string message;\n string type;\n bool isReadFlag;\n\npublic:\n Notification(string msg, string t)\n : message(msg), type(t), isReadFlag(false) {}\n\n string getMessage() const { return message; }\n string getType() const { return type; }\n bool isRead() const { return isReadFlag; }\n void markRead() { isReadFlag = true; }\n};\n\nclass NotificationCenter {\nprivate:\n vector notifications;\n\npublic:\n void add(const Notification& n) {\n notifications.push_back(n);\n }\n\n Notification& getAt(int index) {\n return notifications[index];\n }\n\n int getSize() const {\n return notifications.size();\n }\n};\n\nclass AllNotificationsIterator {\nprivate:\n NotificationCenter* center;\n int index;\n\npublic:\n AllNotificationsIterator(NotificationCenter* c) : center(c), index(0) {}\n\n bool hasNext() { return index < center->getSize(); }\n\n Notification& next() {\n return center->getAt(index++);\n }\n};\n\nclass FilteredIterator {\nprivate:\n NotificationCenter* center;\n string type;\n int index;\n\n void advanceToNext() {\n while (index < center->getSize()\n && center->getAt(index).getType() != type) {\n index++;\n }\n }\n\npublic:\n FilteredIterator(NotificationCenter* c, string t)\n : center(c), type(t), index(0) {\n advanceToNext();\n }\n\n bool hasNext() { return index < center->getSize(); }\n\n Notification& next() {\n Notification& n = center->getAt(index);\n index++;\n advanceToNext();\n return n;\n }\n};\n\nclass UnreadIterator {\nprivate:\n NotificationCenter* center;\n int index;\n\n void advanceToNext() {\n while (index < center->getSize()\n && center->getAt(index).isRead()) {\n index++;\n }\n }\n\npublic:\n UnreadIterator(NotificationCenter* c) : center(c), index(0) {\n advanceToNext();\n }\n\n bool hasNext() { return index < center->getSize(); }\n\n Notification& next() {\n Notification& n = center->getAt(index);\n index++;\n advanceToNext();\n return n;\n }\n};\n\nint main() {\n NotificationCenter center;\n center.add(Notification(\"Your order shipped\", \"EMAIL\"));\n center.add(Notification(\"Flash sale today!\", \"PUSH\"));\n center.add(Notification(\"Verify your number\", \"SMS\"));\n center.add(Notification(\"Invoice ready\", \"EMAIL\"));\n center.add(Notification(\"New login detected\", \"PUSH\"));\n\n center.getAt(0).markRead();\n center.getAt(2).markRead();\n\n cout << \"--- All Notifications ---\" << endl;\n AllNotificationsIterator all(¢er);\n while (all.hasNext()) {\n cout << \" \" << all.next().getMessage() << endl;\n }\n\n cout << \"\\n--- Email Only ---\" << endl;\n FilteredIterator emails(¢er, \"EMAIL\");\n while (emails.hasNext()) {\n cout << \" \" << emails.next().getMessage() << endl;\n }\n\n cout << \"\\n--- Unread Only ---\" << endl;\n UnreadIterator unread(¢er);\n while (unread.hasNext()) {\n cout << \" \" << unread.next().getMessage() << endl;\n }\n\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\ntype Notification struct {\n\tmessage string\n\ttyp string\n\tread bool\n}\n\nfunc NewNotification(message, typ string) Notification {\n\treturn Notification{message: message, typ: typ, read: false}\n}\n\nfunc (n *Notification) MarkRead() {\n\tn.read = true\n}\n\nfunc (n Notification) String() string {\n\tstatus := \"unread\"\n\tif n.read {\n\t\tstatus = \"read\"\n\t}\n\treturn fmt.Sprintf(\"[%s] %s (%s)\", n.typ, n.message, status)\n}\n\ntype NotificationIterator interface {\n\tHasNext() bool\n\tNext() Notification\n}\n\ntype NotificationCenter struct {\n\tnotifications []Notification\n}\n\nfunc (c *NotificationCenter) Add(notification Notification) {\n\tc.notifications = append(c.notifications, notification)\n}\n\nfunc (c *NotificationCenter) GetAt(index int) *Notification {\n\treturn &c.notifications[index]\n}\n\nfunc (c *NotificationCenter) GetSize() int {\n\treturn len(c.notifications)\n}\n\nfunc (c *NotificationCenter) CreateIterator() NotificationIterator {\n\treturn &AllNotificationsIterator{center: c}\n}\n\nfunc (c *NotificationCenter) CreateFilteredIterator(typ string) NotificationIterator {\n\treturn &FilteredIterator{center: c, typ: typ, index: 0}\n}\n\nfunc (c *NotificationCenter) CreateUnreadIterator() NotificationIterator {\n\treturn &UnreadIterator{center: c, index: 0}\n}\n\ntype AllNotificationsIterator struct {\n\tcenter *NotificationCenter\n\tindex int\n}\n\nfunc (it *AllNotificationsIterator) HasNext() bool {\n\treturn it.index < it.center.GetSize()\n}\n\nfunc (it *AllNotificationsIterator) Next() Notification {\n\tnotification := it.center.notifications[it.index]\n\tit.index++\n\treturn notification\n}\n\ntype FilteredIterator struct {\n\tcenter *NotificationCenter\n\ttyp string\n\tindex int\n}\n\nfunc (it *FilteredIterator) advanceToNext() {\n\tfor it.index < it.center.GetSize() && it.center.notifications[it.index].typ != it.typ {\n\t\tit.index++\n\t}\n}\n\nfunc (it *FilteredIterator) HasNext() bool {\n\treturn it.index < it.center.GetSize()\n}\n\nfunc (it *FilteredIterator) Next() Notification {\n\tnotification := it.center.notifications[it.index]\n\tit.index++\n\tit.advanceToNext()\n\treturn notification\n}\n\ntype UnreadIterator struct {\n\tcenter *NotificationCenter\n\tindex int\n}\n\nfunc (it *UnreadIterator) advanceToNext() {\n\tfor it.index < it.center.GetSize() && it.center.notifications[it.index].read {\n\t\tit.index++\n\t}\n}\n\nfunc (it *UnreadIterator) HasNext() bool {\n\treturn it.index < it.center.GetSize()\n}\n\nfunc (it *UnreadIterator) Next() Notification {\n\tnotification := it.center.notifications[it.index]\n\tit.index++\n\tit.advanceToNext()\n\treturn notification\n}\n\nfunc main() {\n\tcenter := &NotificationCenter{}\n\tcenter.Add(NewNotification(\"Your order shipped\", \"EMAIL\"))\n\tcenter.Add(NewNotification(\"Flash sale today!\", \"PUSH\"))\n\tcenter.Add(NewNotification(\"Verify your number\", \"SMS\"))\n\tcenter.Add(NewNotification(\"Invoice ready\", \"EMAIL\"))\n\tcenter.Add(NewNotification(\"New login detected\", \"PUSH\"))\n\n\t// Mark some as read\n\tcenter.GetAt(0).MarkRead()\n\tcenter.GetAt(2).MarkRead()\n\n\tfmt.Println(\"--- All Notifications ---\")\n\tall := center.CreateIterator()\n\tfor all.HasNext() {\n\t\tfmt.Println(\" \", all.Next())\n\t}\n\n\tfmt.Println(\"\\n--- Email Only ---\")\n\temails := center.CreateFilteredIterator(\"EMAIL\")\n\tfor emails.HasNext() {\n\t\tfmt.Println(\" \", emails.Next())\n\t}\n\n\tfmt.Println(\"\\n--- Unread Only ---\")\n\tunread := center.CreateUnreadIterator()\n\tfor unread.HasNext() {\n\t\tfmt.Println(\" \", unread.Next())\n\t}\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\nclass Notification\n{\n public string Message { get; }\n public string Type { get; }\n public bool IsRead { get; private set; }\n\n public Notification(string message, string type)\n {\n Message = message;\n Type = type;\n IsRead = false;\n }\n\n public void MarkRead() { IsRead = true; }\n\n public override string ToString()\n {\n string status = IsRead ? \"read\" : \"unread\";\n return $\"[{Type}] {Message} ({status})\";\n }\n}\n\ninterface INotificationIterator\n{\n bool HasNext();\n Notification Next();\n}\n\nclass NotificationCenter\n{\n private List notifications = new List();\n\n public void Add(Notification n) { notifications.Add(n); }\n public Notification GetAt(int index) { return notifications[index]; }\n public int GetSize() { return notifications.Count; }\n\n public INotificationIterator CreateIterator()\n {\n return new AllNotificationsIterator(this);\n }\n\n public INotificationIterator CreateFilteredIterator(string type)\n {\n return new FilteredIterator(this, type);\n }\n\n public INotificationIterator CreateUnreadIterator()\n {\n return new UnreadIterator(this);\n }\n}\n\nclass AllNotificationsIterator : INotificationIterator\n{\n private NotificationCenter center;\n private int index = 0;\n\n public AllNotificationsIterator(NotificationCenter center)\n {\n this.center = center;\n }\n\n public bool HasNext() { return index < center.GetSize(); }\n public Notification Next() { return center.GetAt(index++); }\n}\n\nclass FilteredIterator : INotificationIterator\n{\n private NotificationCenter center;\n private string type;\n private int index = 0;\n\n public FilteredIterator(NotificationCenter center, string type)\n {\n this.center = center;\n this.type = type;\n AdvanceToNext();\n }\n\n private void AdvanceToNext()\n {\n while (index < center.GetSize()\n && center.GetAt(index).Type != type)\n index++;\n }\n\n public bool HasNext() { return index < center.GetSize(); }\n\n public Notification Next()\n {\n Notification n = center.GetAt(index);\n index++;\n AdvanceToNext();\n return n;\n }\n}\n\nclass UnreadIterator : INotificationIterator\n{\n private NotificationCenter center;\n private int index = 0;\n\n public UnreadIterator(NotificationCenter center)\n {\n this.center = center;\n AdvanceToNext();\n }\n\n private void AdvanceToNext()\n {\n while (index < center.GetSize() && center.GetAt(index).IsRead)\n index++;\n }\n\n public bool HasNext() { return index < center.GetSize(); }\n\n public Notification Next()\n {\n Notification n = center.GetAt(index);\n index++;\n AdvanceToNext();\n return n;\n }\n}\n\nclass Program\n{\n static void Main()\n {\n var center = new NotificationCenter();\n center.Add(new Notification(\"Your order shipped\", \"EMAIL\"));\n center.Add(new Notification(\"Flash sale today!\", \"PUSH\"));\n center.Add(new Notification(\"Verify your number\", \"SMS\"));\n center.Add(new Notification(\"Invoice ready\", \"EMAIL\"));\n center.Add(new Notification(\"New login detected\", \"PUSH\"));\n\n center.GetAt(0).MarkRead();\n center.GetAt(2).MarkRead();\n\n Console.WriteLine(\"--- All Notifications ---\");\n var all = center.CreateIterator();\n while (all.HasNext())\n Console.WriteLine($\" {all.Next()}\");\n\n Console.WriteLine(\"\\n--- Email Only ---\");\n var emails = center.CreateFilteredIterator(\"EMAIL\");\n while (emails.HasNext())\n Console.WriteLine($\" {emails.Next()}\");\n\n Console.WriteLine(\"\\n--- Unread Only ---\");\n var unread = center.CreateUnreadIterator();\n while (unread.HasNext())\n Console.WriteLine($\" {unread.Next()}\");\n }\n}\n```\n\n```typescript\nclass Notification {\n public read: boolean = false;\n public readonly message: string;\n public readonly type: string;\n\n constructor(message: string, type: string) {\n this.message = message;\n this.type = type;\n }\n\n markRead(): void {\n this.read = true;\n }\n\n toString(): string {\n const status = this.read ? \"read\" : \"unread\";\n return `[${this.type}] ${this.message} (${status})`;\n }\n}\n\ninterface NotificationIterator {\n hasNext(): boolean;\n next(): Notification;\n}\n\nclass NotificationCenter {\n private notifications: Notification[] = [];\n\n add(notification: Notification): void {\n this.notifications.push(notification);\n }\n\n getAt(index: number): Notification {\n return this.notifications[index];\n }\n\n getSize(): number {\n return this.notifications.length;\n }\n\n createIterator(): NotificationIterator {\n return new AllNotificationsIterator(this);\n }\n\n createFilteredIterator(type: string): NotificationIterator {\n return new FilteredIterator(this, type);\n }\n\n createUnreadIterator(): NotificationIterator {\n return new UnreadIterator(this);\n }\n}\n\nclass AllNotificationsIterator implements NotificationIterator {\n private index = 0;\n private center: NotificationCenter;\n\n constructor(center: NotificationCenter) {\n this.center = center;\n }\n\n hasNext(): boolean {\n return this.index < this.center.getSize();\n }\n\n next(): Notification {\n return this.center.getAt(this.index++);\n }\n}\n\nclass FilteredIterator implements NotificationIterator {\n private index = 0;\n private center: NotificationCenter;\n private type: string;\n\n constructor(center: NotificationCenter, type: string) {\n this.center = center;\n this.type = type;\n this.advanceToNext();\n }\n\n private advanceToNext(): void {\n while (\n this.index < this.center.getSize() &&\n this.center.getAt(this.index).type !== this.type\n ) {\n this.index++;\n }\n }\n\n hasNext(): boolean {\n return this.index < this.center.getSize();\n }\n\n next(): Notification {\n const n = this.center.getAt(this.index);\n this.index++;\n this.advanceToNext();\n return n;\n }\n}\n\nclass UnreadIterator implements NotificationIterator {\n private index = 0;\n private center: NotificationCenter;\n\n constructor(center: NotificationCenter) {\n this.center = center;\n this.advanceToNext();\n }\n\n private advanceToNext(): void {\n while (\n this.index < this.center.getSize() &&\n this.center.getAt(this.index).read\n ) {\n this.index++;\n }\n }\n\n hasNext(): boolean {\n return this.index < this.center.getSize();\n }\n\n next(): Notification {\n const n = this.center.getAt(this.index);\n this.index++;\n this.advanceToNext();\n return n;\n }\n}\n\nconst center = new NotificationCenter();\ncenter.add(new Notification(\"Your order shipped\", \"EMAIL\"));\ncenter.add(new Notification(\"Flash sale today!\", \"PUSH\"));\ncenter.add(new Notification(\"Verify your number\", \"SMS\"));\ncenter.add(new Notification(\"Invoice ready\", \"EMAIL\"));\ncenter.add(new Notification(\"New login detected\", \"PUSH\"));\n\ncenter.getAt(0).markRead();\ncenter.getAt(2).markRead();\n\nconsole.log(\"--- All Notifications ---\");\nconst all = center.createIterator();\nwhile (all.hasNext()) {\n console.log(\" \" + all.next().toString());\n}\n\nconsole.log(\"\\n--- Email Only ---\");\nconst emails = center.createFilteredIterator(\"EMAIL\");\nwhile (emails.hasNext()) {\n console.log(\" \" + emails.next().toString());\n}\n\nconsole.log(\"\\n--- Unread Only ---\");\nconst unread = center.createUnreadIterator();\nwhile (unread.hasNext()) {\n console.log(\" \" + unread.next().toString());\n}\n```\n\n\nThe important thing to notice: the client loop is identical for all three iterators. `while (hasNext()) { next() }`. The filtering, skipping, and type-checking logic lives entirely inside the iterator classes. Adding a new traversal mode (say, \"only push notifications from the last hour\") means creating one new iterator class. The `NotificationCenter` and existing iterators remain unchanged.","pageType":"lld-interviews"}

Get Premium