📚 Table of Contents

• What is the Iterator Design Pattern?
• Key Participants
• Real world Analogy
• UML Diagram

• Full Java Example

  • User Class
  • MyIterator Interface
  • MyIneratorImpl
  • UserManagement
  • Main Client Code

• Use Cases

• Advantages

• Disadvantages

• When to Use and Not to Use

• Internal vs External Iterators

• Comparison with Java’s Built-in Iterators

• Best Practices and Pitfalls

• Alternatives

• Summary

🌀 Iterator Design Pattern in Java – Explained with a Custom User Management Example

📌 What is the Iterator Design Pattern?

The Iterator Design Pattern is a behavioral design pattern that provides a way to sequentially access elements of a collection without exposing its internal structure.

Think of it as a clean way to loop through complex data structures like trees, graphs, or even simple collections, without the caller needing to know how the elements are stored internally.

🧑‍🤝‍🧑 Key Participants

In the context of our example:

🛒 Real world Analogy

Think of user management in a web app. The admin doesn’t care how users are stored (array, list, map). They just want to browse user profiles one by one — next user, next user...

That’s what the iterator does — lets the admin move across users without exposing the backend logic.

📊 UML Diagram (Text Format)

 +--------------------+ +------------------------+ | MyIterator |<------+ MyIneratorImpl | +--------------------+ +------------------------+ | +hasNext():boolean | | -list: List<User> | | +next(): Object | | -index: int | +--------------------+ | +hasNext() | | +next() | +------------------------+ +------------------------+ | UserManagement | +------------------------+ | -list: List<User> | | +addUser(User) | | +getIterator():Iterator| +------------------------+ +-------------+ | User | +-------------+ | -name | | -emailID | | +getName() | | +getEmailID()| +-------------+ 

💻 Full Java Implementation

1. User – The Element Object

package org.example; public class User { private String name; private String emailID; public User(String name, String emailID) { this.name = name; this.emailID = emailID; } public String getName() { return name; } public String getEmailID() { return emailID; } } 

2. MyIterator – The Iterator Interface

package org.example; public interface MyIterator { boolean hasNext(); Object next(); } 

3. MyIneratorImpl – Concrete Iterator

package org.example; import java.util.List; public class MyIneratorImpl implements MyIterator { private List<User> list; private int index; public MyIneratorImpl(List<User> list) { this.list = list; this.index = 0; } public boolean hasNext() { return index < list.size(); } public Object next() { return list.get(index++); } } 

4. UserManagement – Aggregate Class

package org.example; import java.util.ArrayList; public class UserManagement { private ArrayList<User> list = new ArrayList<>(); public void addUser(User user) { list.add(user); } public MyIterator getIterator() { return new MyIneratorImpl(list); } } 

5. Main – Client Code

package org.example; public class Main { public static void main(String[] args) { UserManagement userManagement = new UserManagement(); User user1 = new User("User1", "user1@gmail.com"); User user2 = new User("User2", "user2@gmail.com"); userManagement.addUser(user1); userManagement.addUser(user2); MyIterator iterator = userManagement.getIterator(); while (iterator.hasNext()) { User user = (User) iterator.next(); System.out.println(user.getName() + " - " + user.getEmailID()); } } } 

🛠 Use Cases in Real-World Systems

• Traversing elements in custom collection classes
• Paging through user records, log entries, or audit history
• Abstracting tree traversal in file systems or DOM trees
• Iterating over results of complex computations

✅ Advantages

• Decouples iteration logic from collection
• Allows different traversal strategies (e.g., reverse, conditional)
• Enables multiple iterators on same collection
• Supports lazy evaluation if needed

❌ Disadvantages

• Additional boilerplate code for small or simple collections
• Requires maintenance of custom iterator classes
• Can be error-prone if next() used without hasNext()

🧭 When to Use and When Not To Use

✅ Use When:

• You want to traverse a collection in a standard way
• Internal data structure should remain hidden
• Multiple types of iteration are needed

❌ Avoid When:

• Java’s built-in Iterator or enhanced for-loop suffices
• Performance is critical and abstraction adds overhead
• Collections are simple and don’t require abstraction

🔄 Internal vs External Iterators

🔍 Comparison with Java Built-in Iterators

🧑‍🏫 Best Practices and Pitfalls

✅ Best Practices:

• Add type safety with generics (MyIterator<T>)
• Check hasNext() before calling next()
• Prefer Iterable<T> interface to support enhanced for-loop
• Keep iterator logic inside collection class if possible

⚠️ Pitfalls:

• Don’t call next() without hasNext() — may cause IndexOutOfBoundsException
• Don’t modify list during iteration (unless supported)
• Avoid exposing mutable internal data via next()

🔁 Alternatives

📝 Summary (Bullet Points)

• The Iterator Pattern provides a standard way to iterate collections without exposing internals.
• We implemented MyIterator, MyIneratorImpl, UserManagement, and User to demonstrate it.
• Separation of concerns: collection logic and iteration logic are independent.
• Java provides built-in Iterator/Iterable that are preferable in production.
• Consider using Streams or for-each for simpler use cases.
• Useful in designing robust and flexible custom collection classes.

📚 Explore More Design Patterns in Java

• 🔒 Mastering the Singleton Design Pattern in Java – A Complete Guide
• ⚠️ Why You Should Avoid Singleton Pattern in Modern Java Projects
• 🏭 Factory Design Pattern in Java – A Complete Guide
• 🧰 Abstract Factory Design Pattern in Java – Complete Guide with Examples
• 🧱 Builder Design Pattern in Java – A Complete Guide
• 👀 Observer Design Pattern in Java – Complete Guide
• 🔌 Adapter Design Pattern in Java – A Complete Guide
• 🔌 Strategy Design Pattern in Java – A Complete Guide
• 🔁 Decorator Design Pattern in Java – Complete Guide

More Details:

Get all articles related to system design
Hastag: SystemDesignWithZeeshanAli

systemdesignwithzeeshanali

Git: https://github.com/ZeeshanAli-0704/SystemDesignWithZeeshanAli