• Iterator Interface: This defines the standard protocol used to navigate through elements. Typically, it contains functions like next() to get the next element in the sequence and hasNext() to see if there is another element.
• Concrete Iterator: The Concrete Iterator is responsible for implementing the Iterator interface and maintaining track of the current position while traversing the collection. It can maintain its current position and gain access to collection elements.
• Aggregate Interface: An interface that specifies how to create an iterator object is known as an aggregate interface. It serves as the interface that the client uses to access the Iterator.
• Concrete Aggregate: The Aggregate interface is implemented by Concrete Aggregate. It is a collection class (such as a list, tree, or graph) that provides the Iterator to traverse its elements. It creates and returns an instance of the Concrete Iterator.

Implementation of Iterator Pattern

Let's consider a book collection in a library. We want to provide a way to iterate through the books without exposing the underlying data structure of the collection.

// Iterator Interface
interface Iterator {
    hasNext(): Boolean
    next(): Object
}

// Concrete Iterator for Book Collection
class BookIterator implements Iterator {
    private currentIndex = 0
    private collection: BookCollection

    BookIterator(BookCollection collection) {
        this.collection = collection
    }

    hasNext(): Boolean {
        return currentIndex < collection.getLength()
    }

    next(): Object {
        if (this.hasNext()) {
            book = collection.getAt(currentIndex)
            currentIndex += 1
            return book
        }
        return null
    }
}

// Aggregate Interface
interface Aggregate {
    createIterator(): Iterator
}

// Concrete Aggregate for Books
class BookCollection implements Aggregate {
    private books: Array

    BookCollection() {
        books = new Array()
    }

    addBook(book: Book) {
        books.append(book)
    }

    getLength(): Integer {
        return books.length
    }

    getAt(index: Integer): Book {
        return books[index]
    }

    createIterator(): Iterator {
        return new BookIterator(this)
    }
}

// Client Code
main() {
    bookCollection = new BookCollection()
    bookCollection.addBook(new Book("Book 1"))
    bookCollection.addBook(new Book("Book 2"))
    // Add more books...

    iterator = bookCollection.createIterator()

    while (iterator.hasNext()) {
        book = iterator.next()
        print(book.title)
    }
}

• Iterator Interface: The iterator interface defines the hasNext() and next() methods. It provides a method of sequentially accessing elements within a collection without disclosing the collection's underlying structure.
• BookIterator (Concrete Iterator): Implements the Iterator interface for the book collection. It allows for sequential access to its elements and maintains track of the current position within the collection.
• Aggregate Interface: Provides a method for generating an iterator called createIterator().
• Concrete Aggregate (BookCollection): Implements the Aggregate interface. It is a collection of books that has the ability to generate a BookIterator for iterating through them.
• Client: The client (similar to a library system) interacts with the collection via the Iterator. It accesses each book sequentially by requesting an Iterator from the BookCollection.

Let's look at the implementation of this example in multiple programming languages.

Implementation