Comparison of for Loops and Iterators

1. Introduction

for loops and Iterators, both provide mechanisms to traverse through collections of elements. While both serve the purpose of iterating over collections, they differ in their syntax, functionality, and applicability.

In this tutorial, we’ll explore a detailed comparison between for loops and iterators, highlighting their key distinctions in several aspects.

We’ll use the following list of strings to demonstrate:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

2. Forward Traversal

In this section, we’ll explore the forward traversal methods for both for loops and iterators.

2.1. With for Loops

Traditional for loops in Java are designed for forward iteration. They start from an initial index and move toward the end of the collection, processing each element in sequential order.

Let’s iterate forward using a for loop:

StringBuilder stringBuilder = new StringBuilder(); 
for (int i = 0; i < names.size(); i++) { 
    stringBuilder.append(names.get(i)); 
} 
assertEquals("AliceBobCharlie", stringBuilder.toString());

2.2. With Iterators

Iterators, by default, offer forward-only traversal. The hasNext() method checks for the existence of the next element, and the next() method moves the iterator to the next position in the collection:

StringBuilder stringBuilder = new StringBuilder();
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    stringBuilder.append(iterator.next());
}
assertEquals("AliceBobCharlie", stringBuilder.toString());

3. Backward Traversal

In this section, we’ll explore the backward traversal methods for both for loops and iterators.

3.1. With for Loops

While it’s possible to simulate backward traversal by manipulating the for loop variable, it isn’t as straightforward as forward iteration. Let’s iterate backward using a for loop:

StringBuilder stringBuilder = new StringBuilder();
for (int i = names.size() - 1; i >= 0; i--) {
    stringBuilder.append(names.get(i));
}
assertEquals("CharlieBobAlice", stringBuilder.toString());

3.2. With Iterators

However,  if a collection implements the List interface and provides a ListIterator, we can achieve backward iteration using the hasPrevious() and previous() methods:

StringBuilder stringBuilder = new StringBuilder();
ListIterator<String> listIterator = names.listIterator(names.size());
while (listIterator.hasPrevious()) {
    stringBuilder.append(listIterator.previous());
}
assertEquals("CharlieBobAlice", stringBuilder.toString());

4. Removal of Elements

In this section, we’ll explore the remove methods in both for loops and iterators.

4.1. With for Loops

for loops aren’t directly compatible with removing elements from the collection being traversed. Modifying the collection during a for loop iteration can lead to unpredictable behavior as the size of the collection is modified. This often results in ConcurrentModificationException or incorrect indices.

Let’s test out the remove() method during looping:

assertThrows(ConcurrentModificationException.class, () -> {
    for (String name : names) {
        names.remove("Bob");
    }
});

4.2. With Iterators

Iterators, on the other hand, provide a safe and reliable way to remove elements during iteration using the remove() method. Iterator internally maintains a cursor or a position within the collection. When we call remove(), it knows exactly which element to remove based on its internal state. This prevents concurrent modification issues and ensures the integrity of the iteration process.

Let’s test out the remove() method with Iterator:

Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("Bob")) {
        iterator.remove();
    }
}
List<String> expected = Arrays.asList("Alice", "Charlie");
assertIterableEquals(expected, names);

5. Flexibility

In this section, we’ll explore the flexibility to alter elements during iteration in both for loops and iterators.

5.1. With for Loops

for loops provide direct access to the elements of a collection based on their indices. This offers flexibility in terms of modification and access, as we have explicit control over the index and can easily perform insertions and modification operations:

for (int i = 0; i < names.size(); i++) {
    names.set(i, names.get(i).toLowerCase());
}
List<String> expected = Arrays.asList("alice","bob", "charlie");
assertIterableEquals(expected, names);

5.2. With Iterators

Iterators, while excellent for traversal and removal, don’t provide direct access to index-based operations. The Iterator interface focuses on forward-only traversal and removal, limiting the ability to directly insert or modify elements. If we need to add or modify elements using Iterator, we may want to consider ListIterator.

6. Error-proneness

for loops are more prone to errors due to their reliance on index-based access. Incorrect index values or modifications to the collection during iteration can lead to various exceptions and unexpected behavior. For example, for loop can lead to IndexOutOfBoundException if the index value is outside the bounds of the collection. This can happen if the index variable isn’t properly initialized or if the collection size is modified during iteration.

On the other hand, Iterator enforces hasNext() checks before accessing elements, preventing null pointer exceptions. This ensures that the Iterator points to a valid element before attempting to access it.

7. Code Readability

for loops are generally considered more readable and concise for simple iterations over collections due to their straightforward syntax. The loop structure clearly conveys the iteration logic, with the index variable explicitly indicating the current position in the collection. This makes it easy to understand the code and follow the flow of the iteration.

While Iterator offers benefits for complex scenarios, it can introduce some readability challenges for simple iterations. Iterators require method calls like hasNext() or next() to iterate through the collection. These method calls can introduce additional complexity and make the iteration logic less clear compared to the concise syntax of a for loop.

8. Choosing Between Iterators and for Loops

In summary, for loops are suitable for simple iteration, especially when direct access to indices is beneficial.

Iterators, on the other hand, are powerful when dealing with safe removal, forward-only traversal, and when working with various collection types.

The following table shows the main differences between the for loop and Iterator:

9. Conclusion

In this article, we discussed the difference between for loops and an Iterators.

for loops provides a straightforward approach for simple forward traversal, while Iterators are powerful when dealing with safe removal and forward-only traversal.

As always, the source code for the examples is available over on GitHub.