Imagine a giant library filled with shelves that stretch beyond the eye. Every shelf contains words. Numbers. Objects. Neatly placed in order.
You step inside. Before you can touch anything, a calm figure appears. A librarian in a long cloak. He speaks softly: “You may take one item at a time. Ask first. Never grab on your own.”
That librarian is the Iterator in Java.Image Placeholder
The Hall of Collections
Picture a shelf of items like this:
["madam", "hello", "racecar", "test", "level"]
You try to pick one.
The librarian raises a hand.
“Patience. Ask me if there is something next. If there is, I will hand it to you.”
This is how the Iterator works.
It allows you to move through a collection in a clean, controlled path.
Iterator<String> it = collection.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
You ask the librarian if more items exist. If yes, he gives you the next one. Ask without checking and Java throws an angry exception.
NoSuchElementException
A Custom Iterator: The Secret Club of Palindromes
Now imagine a private order in this world. Only special words get invited. Words that read the same forward and backward. Palindromes.
We write a class that filters such words and offers a custom Iterator that returns only the accepted members.
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
public class Palindrome implements Iterable<String> {
private final List<String> palindromes;
public Palindrome(List<String> input) {
if (input == null) {
throw new IllegalArgumentException("Input list cannot be null");
}
this.palindromes = filterPalindromes(input);
}
private List<String> filterPalindromes(List<String> input) {
List<String> buffer = new ArrayList<>();
for (String s : input) {
if (s != null && isPalindrome(s)) {
buffer.add(s);
}
}
return buffer;
}
private boolean isPalindrome(String s) {
int left = 0;
int right = s.length() - 1;
while (left < right) {
if (s.charAt(left) != s.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
@Override
public Iterator<String> iterator() {
return new MyListIterator();
}
public class MyListIterator implements Iterator<String> {
private int cursor = 0;
@Override
public boolean hasNext() {
return cursor < palindromes.size();
}
@Override
public String next() {
if (!hasNext()) {
throw new NoSuchElementException("No more palindrome entries");
}
return palindromes.get(cursor++);
}
}
}
Testing the Spell
public class App {
public static void main(String[] args) {
Palindrome p = new Palindrome(Arrays.asList("madam", "hello", "racecar", "test", "level"));
Iterator<String> palindromeIterator = p.iterator();
while (palindromeIterator.hasNext()) {
System.out.println(palindromeIterator.next());
}
}
}
Expected output:
madam
racecar
level
Only the true members of the order remain. The Iterator acts as a gatekeeper. Only those that match the rule are allowed through.
Why Iterators Matter
Without a guide, you would try to pull everything out of a collection in one wild grab. That turns into a mess. Programs break. Bugs appear. An Iterator provides rhythm. A steady step through data. A polite way to move.
Conclusion
A collection on its own is only a container. Its true power is revealed when you can move through it with precision. The Iterator provides that structure. It hands each element in order, prevents reckless access, and enforces a disciplined pattern of traversal. Whether filtering special members like palindromes or iterating through a simple list, the Iterator is the guide that ensures the journey remains clear, controlled, and reliable.
