Iterator differences between JDK 1.6 and 1.7

Question

I'm having an issue with the same code running on two different versions of the JDK. The code basically has nested iterators on the same HashMap. The following is pseudocode. I've inherited this code...

Iterator entries = source.entrySet().iterator();
while(entries.hasNext()) {
    Map.Entry entry = entries.next();

    Iterator otherEntries = source.entrySet().iterator();
    while(otherEntries.hasNext()) {
        Map.Entry otherEntry = otherEntries.next();
        List elements = otherEntry.getValue();

        for(element : elements) {
            ...
        }

        for(someOtherElement : someOtherElement) { 
            if(...) {
                elements.add(someOtherElement);
            }
        }
    }
}

Apologies for the mess of this code but as I mentioned I inherited this. This code runs fine for us in JDK 1.7. In JDK 1.6 (an IBM RSA JDK), the call to "elements.add(...)" also adds the elements to the original "source" HashMaps elements. The "elements" List comes from otherEntry.getValue(). Adding or updating elements seems to cause the source to be updated as it is passed by reference. However, in JDK 1.7 (just a standard one), we don't see the same behaviour. Here calls to "elements.add" do not update or modify the "source" HashMap.

So I'm trying to understand whats going on here and is this something that was changed between JDK's??

Thanks

No, I'm reproducing this on a local tomcat development environment with a single user execution. I'm doing the test on the 1.6 JDK, then switching JDK's and repeating the test and seeing different behaviour... — fatlog, Nov 29 '13 at 11:43

score 3 · Accepted Answer · answered Nov 29 '13 at 11:46

3

There is no change in the behavior of the way instance are passed. But the question whether you see modified list elements depends on the iteration order: you will see modified lists only if you modify lists contained in entries that not have been seen already by the outer Iterator. Since the iteration order might change between different HashMap implementations it might really happen that you see modified lists in one JDK but not another.

The bottom line is that you should not use such nested Iterators. When modifying in one loop and looking into it in another loop after the first loop has been finished you will see the modified lists, reliably.

answered Nov 29 '13 at 11:46

Holger

285,553
42
434
765

hhhmmm, this could be it. The iteration order is different between JDK's. And I wasn't fully aware of this. So, just so I understand, if the outer iteration hasn't touched an element on the list and the inner iteration does, then the list can be modified?? – fatlog Nov 29 '13 at 12:00
The list can be modified in either case; the question is whether it happens *before* or *after* the outer iteration will see that list. If that’s what you have meant then, yes, you have understood. – Holger Nov 29 '13 at 12:06

score 0 · Answer 2 · answered Nov 29 '13 at 11:47

0

The only change I can see from source code is

Three new methods have been added Collections class namely

Collections.emptyIterator
Collections.emptyEnumeration
Collections.emptyListIterator

answered Nov 29 '13 at 11:47

constantlearner

5,157
7
42
64

Iterator differences between JDK 1.6 and 1.7

2 Answers2