Blueprint

The Iterator Pattern Solution

The new code uses the Iterator Pattern, a behavioral design pattern. It lets you visit the elements of a collection without showing how they are stored (list, stack, tree, etc.).

1. How This Solves the Problem

Now the code that walks through the elements is separate from the structure that stores them. Here is what that fixes:

Problem	How Iterator Pattern Solves It
Direct access to internal data	The collection no longer exposes its internal list or array. An iterator gives access to elements one by one, so the structure stays private.
No standard way to iterate	All traversal uses the same two methods (`hasNext()` / `next()`), however the data is stored.
Logic spread across client code	The iterator class keeps track of the position (index). Client code stays short.
Difficult to customize traversal	You can write a new iterator class for each way of walking (reverse, filtering, shuffle). The collection does not change.
Tight coupling to collection type	Client code does not depend on the exact type (ArrayList vs. LinkedList). It uses only the interface, so you can change the type freely.

In the code, createIterator() gives the iterator the playlist's own list. The iterator reads it by position and the client never sees it. next() returns null when no elements are left. Java's own Iterator throws NoSuchElementException instead.

2. Key Improvements

Encapsulation: YouTubePlaylist no longer leaks its internal List<Video>.
Abstraction: The client does not know about the indices or the data structure.
Uniformity: The Playlist interface lets you add other collections (e.g., MusicPlaylist) that are walked in exactly the same way.
SOLID Compliance: It follows the Single Responsibility Principle, because storing data and walking through it are separate jobs.

3. Ideal Scenarios for Using the Iterator Pattern

The Iterator Pattern fits these situations:

Hiding Complex Internals: Use it to walk through a collection (like a Tree or Graph) without revealing whether it is an ArrayList, Vector, or a custom structure.
Multiple Traversal Variations: Use it when you need forward, reverse, or "Shuffle Play" order. Each can be its own iterator class.
Unified Access: Use it to walk through different collections (videos, songs, or documents) with the same while loop.
Decoupling Logic: Use it to keep how elements are stored apart from how they are read, so a change in one does not break the other.

4. Summary of the "Remote Control"

Think of the Iterator as a Remote Control and the Playlist as the Television. You do not need to know how the wires work inside the TV. You press "Next" on the remote. If you buy a new TV and the remote works the same way, you learn nothing new.

In this topic

After code1 file

After/Main.java104 linesGitHub

1package DesignPatterns.BehaviouralPatterns.IteratorPattern.After;2import java.util.ArrayList;3import java.util.List;45// A simple Video class with title6class Video {7    String title;89    public Video(String title) {10        this.title = title;11    }1213    public String getTitle() {14        return title;15    }16}1718/**19 * 1. THE AGGREGATE INTERFACE20 * This acts as a contract. Any collection that wants to be iterable21 * must be able to "create" an iterator for itself.22 */23interface Playlist {24    PlaylistIterator createIterator();25}2627/**28 * 2. CONCRETE AGGREGATE29 * Stores the actual data. Notice it no longer has a 'getVideos()' method.30 * Encapsulation is now perfectly preserved.31 */32class YouTubePlaylist implements Playlist {33    // Internal data is now strictly private and hidden from the client34    private List<Video> videos = new ArrayList<>();3536    public void addVideo(Video video) {37        videos.add(video);38    }3940    @Override41    public PlaylistIterator createIterator() {42        // We pass the internal list to a new iterator instance43        return new YouTubePlaylistIterator(videos);44    }45}4647/**48 * 3. THE ITERATOR INTERFACE49 * Defines the standard operations for traversing ANY collection50 * without knowing how that collection is stored.51 */52interface PlaylistIterator {53    boolean hasNext(); // Is there another element?5455    Video next(); // Give me the next element and move the pointer.56}5758/**59 * 4. CONCRETE ITERATOR60 * This class carries the "State" of the traversal (the 'position' variable).61 * This allows multiple clients to iterate over the SAME playlist simultaneously62 * because each has its own Iterator instance with its own 'position'.63 */64class YouTubePlaylistIterator implements PlaylistIterator {65    private List<Video> videos;66    private int position;6768    public YouTubePlaylistIterator(List<Video> videos) {69        this.videos = videos;70        this.position = 0;71    }7273    @Override74    public boolean hasNext() {75        return position < videos.size();76    }7778    @Override79    public Video next() {80        // Standard safety check before returning data81        return hasNext() ? videos.get(position++) : null;82    }83}8485public class Main {86    public static void main(String[] args) {87        YouTubePlaylist playlist = new YouTubePlaylist();88        playlist.addVideo(new Video("LLD Tutorial"));89        playlist.addVideo(new Video("System Design Basics"));9091        /**92         * CLIENT CODE REVOLUTION:93         * 1. The client doesn't know if 'playlist' uses a List, Array, or Map.94         * 2. The client doesn't manage indices (i=0; i < size).95         * 3. The client cannot accidentally call .clear() on the internal list.96         */97        PlaylistIterator iterator = playlist.createIterator();9899        while (iterator.hasNext()) {100            System.out.println(iterator.next().getTitle());101        }102    }103}104

Iterator Pattern: Sequential Access Without Exposure