Why java Iterator interface should be implemented as inner class?

Question

I recently read a book "The Java Tutorials" 3rd edition. It talks about inner class implementation as the picture shows.

In the 3rd paragraph, it says "The Stack class itself should not implement the Iterator interface, because...".

I cannot find any reason that Stack class should not implement Iterator. The reason given is NOT persvasive.

Could you explain it?

Answer 1

Fundamentally, an iterator is stateful - it needs to know where it's pointing within the collection. That doesn't belong as part of the collection itself - and the explanation given is the right one... it's entirely possible to have two independent iterator objects, iterating over the same collection object. How would you model that if the collection itself implemented the Iterator interface? It's possible (e.g. creating a new instance of the collection which in turn held a reference to the original collection), but it would be really ugly.

There are separate concerns here:

• The collection of data
• A cursor positioned within the collection

Separate concerns => separate classes.

The simplest way of persuading yourself of this is probably to try to implement your own collection though - and then have multiple iterators. For example, you might want to try:

List<String> foo = new MyListImplementation<String>();
foo.add("a");
foo.add("b");

// The enhanced for loop uses Iterable/Iterator for non-arrays
for (String x : foo) {
    for (String y : foo) {
        System.out.println(x + " " + y);
    }
}

That should print out:

a a
a b
b a
b b

Try implementing it without having two classes, and see how you do, bearing separation of concerns in mind.

Answer 2

The stack should not implement Iterator itself because then you could have only one iterator at a time, and iterating over a stack would change the stack.

For the latter issue, notice that the nested class has a "currentItem" field. This field would need to be in "Stack", and would change when next() is called. Iterating over a collection should not change the collection.

The first problem is more serious: suppose two people iterate over the stack (or one method wishes to create two iterators over the stack). Then if iterator() returned this, the two iterators would be the same thing. Calling next() on one would move the other. Chaos.

Answer 3

A Stack cannot be its own Iterator because a Stack supports more than one Iterator.

You might want to iterate over the Stack more than once. These iterations might occur at different times, or even the same time. Multiple iterations at the same time clearly require multiple objects. Multiple iterations at different times require multiple objects because the Iterator interface does not support returning to the start.

Answer 4

There are 2 reasons I can think of off the top of my head.

Multiple types of iterators

You may want multiple types of iterators that iterate in different ways. For instance, both a Forward Iterator and a Backward Iterator (iterates from end of the container to beginning).

Multiple instances of iterators

If you have a multiple pass algorithm and/or nested loops, each loop may want its own iterator that keeps track of where it is in the container independent of the other iterators.

---

It would be difficult if not impossible to support these functionalities with the Iterator interface implemented in the Stack class.