List with multiple Iterators - result predictible?

Question

Hi,
I have a situation where a list is used by two Iterators:
List a;
Iterator i1 = a.iterator();
while (i1.hasNext()) {
Object o1 = i1.next();
Iterator i2 = a.iterator();
while (i2.hasNext()) {
Object o2 = i2.next();
// do something to "o2" - modify or remove through i2.remove()
I have seen other discussions, but my impression is it's mostly "Hash" or "Tree" that has a un-predictible result, or even clearer - fast-failing. For a List, it seems to me what would happen is quite certain (e.g. if the inner iterator removes an object, that object would be gone from the collection, but the outer iterator would still hold a reference to it, thus still be able to access it). However, in Java API, Iterator.remove() method has notes saying it's "unspecified" for all modifications unless using that particular method correctly.
I think this is designed on purpose, but don't know why. Any thoughts?
Thanks,

Answer 1

An Iterator.delete() has the spec:
public void remove()
Removes from the underlying collection the last element returned by the iterator (optional operation). This method can be called only once per call to next. The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.
So when in your example the second iterator modifies the underlying collection it breaks the first instance iterator behavior which has then an unpredictable result.
Using a List.iterator() seems to change nothing :
public Iterator iterator()
Returns an iterator over the elements in this list in proper sequence.
Specified by:
iterator in interface Collection
Returns:
an iterator over the elements in this list in proper sequence.
So you code isn't garanty to run as you quote it running. The i2 is safe not i1 if you use i2.remove().
I did this test:
     List v1 = new Vector();
     v1.add("1");
     v1.add("2");
     v1.add("3");
     Iterator i1 = v1.iterator();
     while (i1.hasNext()) {
          Object o1 = i1.next(); // At second iteration I got a ConcurrentModificationException here.
          Iterator i2 = v1.iterator();
          while (i2.hasNext()) {
               i2.next();
               i2.remove();
          System.out.println(o1);
That's a typical unexpected results because hasNext() answered true but next() failed.
Now if your question is why this spec, I dunno, I could only guess that the purpose of Iterator generic interface is to allow to have efficient implementation at price of non concurent modification access.