Why can't I hold EnumMap entries via a "for" loop, even if I use "final"? Best workaround?

Question

I'm having some strange behaviour.

[UPDATE: Full runnable example given:]

package finaltestwithenummapentry;

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.Map.Entry;

public class FinalTestWithEnumMapEntry {

    enum SomeEnum{
        ONE, TWO, THREE;
    }

    public static void main(String[] args) {
        EnumMap<SomeEnum, Integer> map = new EnumMap<SomeEnum, Integer>(SomeEnum.class);
        map.put(SomeEnum.ONE, 1);
        map.put(SomeEnum.TWO, 2);
        map.put(SomeEnum.THREE, 3);

        ArrayList<Entry<SomeEnum, Integer>> entryList = new ArrayList<Entry<SomeEnum, Integer>>();  

        for(final Entry<SomeEnum, Integer> entry : map.entrySet()){      
            System.out.println("Key is " + entry.getKey() + ", value is " + entry.getValue());     
            //This prints the correct keys and values      

            entryList.add(entry); 
        }  

        System.out.println("");

        for(Entry<SomeEnum, Integer> entry:entryList){     
            System.out.println("Key is " + entry.getKey() + ", value is " + entry.getValue());     
            //This prints only the last entry each time 
        }
    }
}

Output (JavaSE 1.6):

Key is ONE, value is 1
Key is TWO, value is 2
Key is THREE, value is 3

Key is THREE, value is 3
Key is THREE, value is 3
Key is THREE, value is 3

My entry, which I'm presuming is final, is seemingly overwritten by the next one each time. I need to be able to capture the correct entry each time, as I am passing each item to an anonymous inner class instance inside the for loop.

[UPDATE: This problem doesn't exist in Java 7, only Java 6 (and maybe before) ]

UPDATE: I might have to make my code work whether it's compiled against Java 6 or 7, so what's the most efficient workaround for making it work in either case?

Answer 1

I think I've figured out what's going on here, and it has nothing to do with the final keyword. If you remove the final modifier from this line:

for(final Entry<SomeEnum, Integer> entry : map.entrySet()){      

the exact same behavior occurs.

But what's this? From the Map.Entry JavaDocs (emphasis added):

A map entry (key-value pair). The Map.entrySet method returns a collection-view of the map, whose elements are of this class. The only way to obtain a reference to a map entry is from the iterator of this collection-view. These Map.Entry objects are valid only for the duration of the iteration.

...which I read as "don't try to use Map.Entry objects outside of an iteration on the collection-view returned by Map.entrySet" — this invokes undefined behavior.

---

This answer explains it in more detail. The problem the OP sees is related specifically to EnumMap's implementation of Map.Entry.

Answer 2

This is a behaviour in Java 6 and earlier for EnumMap and IdentityHashMap. It was done for the sake of performance (source - Josh Bloch, 13:56, "Java Puzzlers", May 2011 (original video link given by Voo in comment)). It no longer happens as of Java 7, where you can now rely on collected Map.Entry objects, regardless of subsequent iterations.

The best workaround, if you intend to use an entry after the next iteration occurs, is to clone it via

new AbstractMap.SimpleImmutableEntry(entry)

and use that instead.

Answer 3

OK, I went spelunking into the source code - EnumMap does a very weird thing when it comes to sending out the keySet, valueSet and entrySet. From the JDK Source code:

/**
 * Since we don't use Entry objects, we use the Iterator itself as entry.
 */
private class EntryIterator extends EnumMapIterator<Map.Entry<K,V>>
        implements Map.Entry<K,V>
{
    public Map.Entry<K,V> next() {
        if (!hasNext())
            throw new NoSuchElementException();
        lastReturnedIndex = index++;
        return this;
    }

They have a bunch of custom classes in EnumMap that return the value during the iteration, thus the reason they don't want you to use it outside that iterator.

That's why it behaves differently than other Map.Entry. The solution for you is to keep/create a separate map/list and fill it with the keys/values, instead of keeping the Entry objects.

(old answer below)

'final' in this case defines that behavior for a single iteration. If you're passing it to an inner class, define final at the class entry point:

for(final Entry<K, V> entry : map.entrySet()){ 
  System.out.println("Key is " + entry.getKey() + ", value is " + entry.getValue());
  //This prints the correct keys and values
  doSomething(entry);
}

private void doSomething(final Entry<K,V> entry){}

Like that.

Answer 4

What do you mean by this?

//This prints only the last entry each time

Using this piece of code (Java 7):

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;

public class ForeachLoopWithFinal {

enum MyEnum {
    ONE("one"),
    TWO("two"),
    THREE("three");

    private String name;

    private MyEnum(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

}

public static void main(String[] args) {
    List<Map.Entry<MyEnum, Integer>> entryList = new ArrayList<>();
    Map<MyEnum, Integer> map = new EnumMap<>(MyEnum.class);

    map.put(MyEnum.ONE, 1);
    map.put(MyEnum.TWO, 2);
    map.put(MyEnum.THREE, 3);

    for (final Map.Entry<MyEnum, Integer> entry : map.entrySet()) {
        System.out.printf("Key is %s, value is %s%n", entry.getKey(), entry.getValue());
        entryList.add(entry);
    }

    for (Map.Entry<MyEnum, Integer> entry : entryList) {
        System.out.printf("Key is %s, value is %s%n", entry.getKey(), entry.getValue());
    }
}

}

I get exactly this output. So the exact same number of entries is printed the first and the second time.

Key is one, value is 1
Key is two, value is 2
Key is three, value is 3
Key is one, value is 1
Key is two, value is 2
Key is three, value is 3

Using your example I get the same.

Key is ONE, value is 1
Key is TWO, value is 2
Key is THREE, value is 3

Key is ONE, value is 1
Key is TWO, value is 2
Key is THREE, value is 3

Answer 5

I believe it's because your 'entry' is getting created each time a loop happens so it's actually a new variable each time. If you tried to set entry to something else inside the loop, I believe you'd get a compiler error.

Edit, based on feedback: There must be something you're not showing us.

Map<String, String> map = new HashMap<String, String>();
        map.put("barf", "turd");
        map.put("car", "bar");
        ArrayList<Entry<String, String>> entryList = new ArrayList<Entry<String, String>>();

        //Assuming I have a Map<K,V> called "map":
        for(final Entry<String, String> entry : map.entrySet()){ 
            System.out.println("Key is " + entry.getKey() + ", value is " + entry.getValue());
            //This prints the correct keys and values

            entryList.add(entry);
        }

        for(Entry<String,String> entry:entryList){
            System.out.println("Key is " + entry.getKey() + ", value is " + entry.getValue());
            //This prints only the last entry each time
        }

prints out:

    Key is car, value is bar
    Key is barf, value is turd
    Key is car, value is bar
Key is barf, value is turd

See this post: Iterating over EnumMap#entrySet It will explain things.

Answer 6

According to the Java Language Specification, the enhanced for loop when using an iterator that looks like this:

for ( VariableModifiersopt Type Identifier: Expression) Statement

is exactly equivalent to:

for (I #i = Expression.iterator(); #i.hasNext(); ) {
        VariableModifiersopt Type Identifier = #i.next();
   Statement
}

(where I is the type of Expression.iterator()). In your case, VariableModifiersopt is final. As is clear from the equivalent form, the final applies only to the use of the variable within Statement.