This tutorial explains how to implement
java.lang.Iterable<T> on a class to enable for-each loop based iteration through the collection of objects stored in that class. Tutorial starts off with explaining how
Iterable and for-each loop are related, then explains how to implement
Iterable<T>, and finally shows a Java code example showing
Iterable interface implementation and implementing class’ use in a for-each loop.
Iterable<T> and the for-each loop
Java 5 introduced for-each loop which took away the error-prone aspect of looping, specifically the need to manage loop-counter variable and end-of-loop conditions. All one now needs to do to iterate over a collection using the for-each loop is to write something like this –
list is an instance of
Most of the important in-built collection types now support iteration using the enhanced for-each loop. This is by virtue of their implementing the interface
In fact, any class which implements
Iterable<T>, can be used in a for-each loop to iterate over the objects of type
T which it holds or encapsulates. Extending this logic to the small code snippet we saw above –
MyCollection which implements
Iterable<MyClass>, can be used in a for-each loop to iterate through
MyClass objects stored in it.
Having understood the relationship between implementing
Iterable interface and use of the implementing class in for-each loop, let us now understand how to go about implementing
How to implement Iterable<T> interface
Any class implementing
Iterable<T> needs to follow three simple steps –
- Return an instance of
So, if you have an API/Class containing a collection of
String type of elements, and you want clients of this API to be able to access the
String objects using a for-each loop, then your three steps of implementing
Iterable<String> would go like this –
- Return an instance of
Simple, right! There is a small piece of logic missing though!!How do you get hold of an
Iterator<String> instance pointing to your stored collection?
The general practice in this case is to return the in-built
Iterator instance of the collection class you use to store the iterable objects in your API. So, if you use a
List<String> to store the
String objects to be iterated, then you return
Iterator<String> returned by
List.iterator() method as the output of overridden
Let us see a Java code example to see how
Iterable<T> implementation can be done.
Java code example showing Iterable<T> implementation
Lets take a simple case of aggregation to show an
Iterable<T> implementation in action. For our example scenario we have 2 types –
Department instance holds multiple
Employee instances in a employee list, or
We will make
Department class implement the
Iterable<Employee> interface. Doing so would would allow us to iterate through employees of a department using the for-each loop just by getting hold of a
Department instance. Let us see the code in action now, which will be followed by detailed explanation of the code.
Employee.javais the POJO class in this example. It has only 2 attributes
IterableDepartmentclass contains a List
employeeListwhich is initialized using
IterableDepartment’s only public constructor.
IterableDeptClientfirst creates an employee list consisting of 5 employees, and then passes this employee list to the constructor of the new
IterableDepartmentinstance it creates.
- Then it iterates through the
Employeeobjects in the
IterableDepartmentinstance using a for-each loop.
- In each iteration of the for-each loop, name of the employee encountered is printed. As expected, the for-each loop correctly iterates through the 5
Employeeobjects stored in the
IterableDepartmentinstance, and prints their names.
In the above tutorial we understood how
Iterable interface can be implemented on a class holding a collection of objects. We then saw with a Java code example showing how such a collection can be iterated through using the enhanced for-each loop.