Java | Implementing Iterator and Iterable Interface

Last Updated : 11 Jul, 2025

Iterators are used in Collection framework in Java to retrieve elements one by one. For more details and introduction related to this, see this link.

Why it is needed to implement Iterable interface?

Every class that implements Iterable interface appropriately, can be used in the enhanced For loop (for-each loop). The need to implement the Iterator interface arises while designing custom data structures. Example:

for(Item item: customDataStructure) {
    // do stuff
}

How to implement Iterable interface?

To implement an iterable data structure, we need to:

Implement Iterable interface along with its methods in the said Data Structure
Create an Iterator class which implements Iterator interface and corresponding methods.

We can generalize the pseudo code as follows:

Java

class CustomDataStructure implements Iterable<> {
    
    // code for data structure
    public Iterator<> iterator() {
        return new CustomIterator<>(this);
    }
}
class CustomIterator<> implements Iterator<> {
    
    // constructor
    CustomIterator<>(CustomDataStructure obj) {
        // initialize cursor
    }
    
    // Checks if the next element exists
    public boolean hasNext() {
    }
    
    // moves the cursor/iterator to next element
    public T next() {
    }
    
    // Used to remove an element. Implement only if needed
    public void remove() {
        // Default throws UnsupportedOperationException.
    }
}

Note: The Iterator class can also, be implemented as an inner class of the Data Structure class since it won't be used elsewhere.

How next() and hasNext() work? To implement an Iterator, we need a cursor or pointer to keep track of which element we currently are on. Depending on the underlying data structure, we can progress from one element to another. This is done in the next() method which returns the current element and the cursor advances to next element. Before advancing the pointer, we check whether next element exists. i.e. we can picturize the behind-the-scenes code as follows:
```
While(iterator.hasNext()) { //if next element exists
    next(); // advance the pointer
}
```
Initializing the cursor The cursor initialization completely depends on the data structure. For example, in a linked list we would initialize cursor to the head element. In an array list, we would initialize cursor to the 0th element. From the point of view of implementation:
- If the Iterator class is implemented as an inner class, we can simply use "this" keyword (e.g. cursor = CustomDataStructure.this.element) to access the desired element
- If the Iterator class is implemented as a separate class, we can pass this object of the data structure to the iterator class constructor as demonstrated in the example below.

Below program illustrates the use of Iterable interface: Given below is a Custom Linked List which makes use of Generics. The linked list consists of Node objects which contain a Generic data value and pointer to next node. The class provides some standard 'get' methods like getHead() and getTail(), and the necessary Iterator() function, which has to be implemented while implementing Iterable interface. Then the necessary custom class 'ListIterator' is created, which will implement the Iterator interface, along with it the functionalities of hasNext() and next() are also to be implemented. These two functions form the core of Iterable and Iterator interface.

Java

import java.util.Iterator;

// Custom Linked List class using Generics
class List<T> implements Iterable<T> {
    Node<T> head, tail;
    
    // add new Element at tail of the linked list in O(1)
    public void add(T data)
    {
        Node<T> node = new Node<>(data, null);
        if (head == null)
            tail = head = node;
        else {
            tail.setNext(node);
            tail = node;
        }
    }
    
    // return Head
    public Node<T> getHead()
    {
        return head;
    }
    
    // return Tail
    public Node<T> getTail()
    {
        return tail;
    }
    
    // return Iterator instance
    public Iterator<T> iterator()
    {
        return new ListIterator<T>(this);
    }
}

class ListIterator<T> implements Iterator<T> {
    Node<T> current;
    
    // initialize pointer to head of the list for iteration
    public ListIterator(List<T> list)
    {
        current = list.getHead();
    }
    
    // returns false if next element does not exist
    public boolean hasNext()
    {
        return current != null;
    }
    
    // return current data and update pointer
    public T next()
    {
        T data = current.getData();
        current = current.getNext();
        return data;
    }
    
    // implement if needed
    public void remove()
    {
        throw new UnsupportedOperationException();
    }
}

// Constituent Node of Linked List
class Node<T> {
    T data;
    Node<T> next;
    public Node(T data, Node<T> next)
    {
        this.data = data;
        this.next = next;
    }
    
    // Setter getter methods for Data and Next Pointer
    public void setData(T data)
    {
        this.data = data;
    }
    
    public void setNext(Node<T> next)
    {
        this.next = next;
    }
    
    public T getData()
    {
        return data;
    }
    
    public Node<T> getNext()
    {
        return next;
    }
}

// Driver class
class Main {
    public static void main(String[] args)
    {
        // Create Linked List
        List<String> myList = new List<>();
        
        // Add Elements
        myList.add("abc");
        myList.add("mno");
        myList.add("pqr");
        myList.add("xyz");
        
        // Iterate through the list using For Each Loop
        for (String string : myList)
            System.out.println(string);
    }
}