Iterator Design Pattern in Java

Back to: Java Design Patterns

Iterator Design Pattern in Java

In this article, I am going to discuss the Iterator Design Pattern in Java with Examples. Please read our previous article where we discussed the Interpreter Design Pattern in Java with Examples. The Iterator Design Pattern falls under the category of Behavioral Design Pattern. In this article, we will explore the fundamental principles, benefits, and potential drawbacks of the Iterator design pattern, highlighting its significance in simplifying collection traversal and enabling flexible iteration strategies.

What is Iterator Design Pattern?

In software development, efficiently traversing and accessing the elements of a collection is a common requirement. The Iterator design pattern provides an elegant solution to this challenge by separating the traversal logic from the collection itself. By encapsulating iteration within a separate iterator object, the pattern enables uniform access to elements while maintaining encapsulation and abstraction.

The Iterator design pattern is a behavioral pattern that decouples the traversal of elements from the collection structure. It provides a uniform interface for accessing elements of a collection without exposing its underlying implementation. The pattern consists of two primary components: the iterator interface and the concrete iterator class. The iterator interface defines the common methods for traversing and accessing elements, while the concrete iterator class implements these methods based on the collection structure. The iterator object maintains its own state, enabling independent iteration over the collection. The client interacts with the iterator to sequentially access the elements without needing to be aware of the internal structure of the collection.

Implementing Iterator Design Pattern in Java

The Iterator pattern can be used to implement the traversal of the collection of students. The collection of students can be represented as an aggregate object, and the iterator provides a way to sequentially access the students in the collection.

When a user wants to browse the students, the application creates an iterator object and associates it with the collection. The iterator provides methods such as “getNext()” or “hasNext()” to iterate over the collection and retrieve the next students in the sequence.

By using the Iterator pattern, the student management application achieves several benefits. Firstly, it provides a standardized interface for iterating over the collection of students, abstracting away the underlying implementation details. The UML Diagram of this example is given below using Iterator Design Pattern.

Step 1: Create a new directory to store all the class files of this project.

Step 2: Open VS Code and create a new project, called iterator.

Step 3: In the project, create a new file called Iterator.java. Add the following code to the file:

public interface Iterator
{
    public boolean hasNext();
    public Object next();
}

This is the interface from which other concrete classes will extend.

Step 4: In the project, create a new file called Container.java. Add the following code to the file:

public interface Container
{
    public Iterator getIterator();    
}

This is the interface from which other concrete classes will extend.

Step 5: In the project, create a new file called Students.java. Add the following code to the file:

public class Students implements Container
{
    public String [] names = {"Student A", "Student B", "Student C"};

    @Override
    public Iterator getIterator()
    {
        return new StudentIterator();
    }

    private class StudentIterator implements Iterator
    {
        private int i;

        @Override
        public boolean hasNext()
        {
            if (i < names.length)
                return true;
            
            return false;
        }

        @Override
        public Object next()
        {
            if (this.hasNext())
                return names[i++];
            
            return null;
        }
        
    }
}

We have added the following pieces of code:

1. Added a list of students for the iterator to iterate through.
2. Added a method that creates and returns the iterator for the student list.
3. Added a new private class that implements the methods from the Iterator interface.

Step 6: In the project, create a new file called IteratorPatternDemo.java. This class will contain the main() function. Add the following code to IteratorPatternDemo.java:

public class IteratorPatternDemo
{
    public static void main(String[] args)
    {
        Iterator i = new Students().getIterator();
        
        while (i.hasNext())
            System.out.println(i.next());
    }    
}

The main function creates an object of type Iterator using the Students class. Using this iterator, we can iterate through the contents of the class. We have added a simple while loop to do so. Each element of the student list will be printed to the terminal.

Step 7: Compile and execute the application. Ensure compilation is successful. Verify that the program works as expected.

Congratulations! You now know how to implement iterator patterns!

UML Diagram of Iterator Design Pattern:

Now, let us see the Iterator Design Pattern UML Diagram Components with our Example so that you can easily understand the UML Diagram.

The classes can be described as follows:

1. Container: This is the interface that will define the basic methods that will be implemented by the concrete object class.
2. ConcreteObject: This class implements the Container interface. It contains the ConcreteObjectIterator (as a sub-class).
3. ConcreteObjectIterator: This class acts as an iterator for the ConcreteObject.
4. Iterator: This interface defines the basic function of an interface. These functions will then be implemented by the ConcreteObjectIterator class.
5. DriverClass: This class contains the main() function and is responsible for the simulation of the program.

Advantages of Iterator Design Pattern in Java

The advantages of using the Iterator Design Pattern in Java are as follows:

• Simplified Collection Traversal: The Iterator pattern simplifies the traversal of collections by providing a consistent and uniform interface. It eliminates the need for clients to have knowledge of the specific collection structure or implementation details. Clients can rely on the iterator to sequentially access the elements, regardless of the underlying data structure. This simplification promotes clean and readable code, reducing the potential for errors and enhancing code maintainability.
• Encapsulation and Abstraction: The Iterator pattern encapsulates the traversal logic within the iterator object, keeping it separate from the collection itself. This encapsulation enhances the principle of information hiding and promotes abstraction. Clients only interact with the iterator object, which shields them from the complexities of the underlying collection. This separation allows for changes in the collection structure or iteration strategy without affecting the client code, ensuring a high level of flexibility and adaptability.
• Support for Multiple Iteration Strategies: The Iterator pattern enables the implementation of multiple iteration strategies for a collection. Different concrete iterator classes can be created to support various traversal approaches, such as forward-only, bidirectional, or filtered iteration. This flexibility allows for tailored iteration strategies based on specific requirements, without modifying the core collection or impacting client code. It promotes code reusability and extensibility, as new iterator implementations can be added without changing existing code.
• Compatibility with Standard Interfaces: The Iterator pattern aligns well with standard collection interfaces and language constructs. Many programming languages provide built-in support for iterators, making it easy to adopt and integrate the pattern. This compatibility enables seamless integration with existing codebases and libraries, leveraging language-specific iterator implementations and conventions.
• Iteration Safety: The Iterator pattern ensures iteration safety by providing a controlled mechanism for traversing collections. The iterator maintains its own state and tracks the current position, preventing concurrent modification exceptions or unintended side effects that may occur when modifying a collection during iteration. This safety feature enhances the reliability and stability of code that involves concurrent access or modification of collections.

Disadvantages of Iterator Design Pattern in Java

The disadvantages of using the Iterator Design Pattern in Java are as follows:

• Increased Complexity for Collection Implementation: Implementing the Iterator pattern can introduce additional complexity to the collection classes. The collection needs to provide an iterator implementation that conforms to the iterator interface, which requires additional code and potentially impacts the performance of collection operations. This complexity can be a concern when designing custom collections or working with performance-critical systems.
• Potential Performance Overhead: The use of iterators can introduce performance overhead compared to direct access to collection elements. Iterators involve method calls and additional objects, which may impact performance-sensitive applications. In scenarios where frequent traversal and element access are crucial, direct access to collection elements may provide better performance.
• Limited Navigational Control: The Iterator pattern provides a sequential, one-way traversal of collection elements. It does not offer built-in support for backward traversal or random access. While it is possible to create custom iterators to support such operations, it can lead to increased complexity and reduced code simplicity. If the ability to navigate in multiple directions or access elements randomly is a core requirement, alternative patterns or approaches may be more suitable.

In the next article, I am going to discuss Memento Design Pattern in Java with Examples. Here, in this article, I try to explain Iterator Design Pattern in Java with Examples. I hope you understood the need for and use of the Iterator Design Pattern in Java.