Refactor Java code safely — and automatically — with
OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to
put off. That’s where OpenRewrite comes in. The open-source
framework for large-scale, automated code transformations helps
teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at
Moderne run live, hands-on training sessions — one for newcomers
and one for experienced users. You’ll see how recipes work, how to
apply them across projects, and how to modernize code with
confidence.
Join the next session,
bring your questions, and learn how to automate the kind of work
that usually eats your sprint time.
Course – Black Friday 2026 – NPI EA – main – before_post_content
Yes, we're now running our Black Friday Sale. All Courses are
33% off until 1st December, 2026 at 17:00
Romania time:
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:
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:
Feature
for Loop
Iterator
Traversal Direction
Forward and backward using indexing
Forward (default), bidirectional with ListIterator
Element Removal
Not directly compatible, can lead to errors
Safe and reliable using remove() method
Flexibility – Insert, Access, Modify
Direct index-based access
Limited to forward-only traversal and removal; ListIterator for modification while iterating
Error-proneness
More prone to errors due to index-based access and potential modifications
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.
The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
Modern Java teams move fast — but codebases
don’t always keep up. Frameworks change, dependencies drift, and
tech debt builds until it starts to drag on delivery. OpenRewrite
was built to fix that: an open-source refactoring engine that
automates repetitive code changes while keeping developer intent
intact.
The monthly training series, led by the creators and maintainers
of OpenRewrite at Moderne, walks through real-world migrations and
modernization patterns. Whether you’re new to recipes or ready to
write your own, you’ll learn practical ways to refactor safely and
at scale.