Re: Enum dictionary issue: will this work?

From:

Roland de Ruiter <roland.de.ruiter@example.invalid>

Newsgroups:

comp.lang.java.programmer

Date:

Thu, 21 Aug 2008 14:35:04 +0200

Message-ID:

<48ad60f9$0$186$e4fe514c@news.xs4all.nl>

On 21-8-2008 12:21, Ben Phillips wrote:

Here's the code. The enum constants should get added to a private map
with a public, unmodifiable view as they are created. It definitely
won't work if the map put is right in the constructor. Will this sort of
thing work as written, with a static method called that initializes the
map if it's null? Or will the map just get clobbered back to null after
the enum constants are all constructed? And if not, will the
unmodifiable view be constructed correctly?

Interesting case. I've rewritten your example so it is compilable:

<SSCCE>
import java.util.*;

public enum Thing {
    FOO("foo"),
    BAR("bar");

    private static Map<String, Thing> thingMap;

    public static final Map<String, Thing> things = Collections
          .unmodifiableMap(thingMap);

    private String name;

    private Thing(String name) {
       this.name = name;
       put(name, this);
    }

    private static void put(String name, Thing thing) {
       if (thingMap == null) {
          thingMap = new HashMap<String, Thing>();
       }
       thingMap.put(name, thing);
    }

    public static void main(String[] args) {
       System.out.println(things);
    }
}
</SSCCE>

It will work "correctly" only because the static "thingMap" field does
not have an initializing expression.

When the enum class Thing loads and gets initialized, the following will
happen and in this order:

Note, that all static fields are null upon class initialization.

1) the enum constant fields are initialized

1a) the enum constant FOO is created: the constructor gets called and as
a side effect also assigns a new map object to the static thingMap
field. This newly created enum object gets stored in the thingMap.

1b) the enum constant BAR is created: constructor is called and this
enum object also gets stored in the thingMap.

2) the static fields are initialized.

2a) Since there isn't an initializing expression for the static
"thingMap" field, the thingMap field will still refer to the map
instance which was created in step 1a.

2b) The static "things" field is assigned with the result of its
initializing expression
    Collections.unmodifiableMap(thingMap)
And because the thingMap field still refers to the map object created in
step 1a, the "things" field refers to an unmodifiable view on that object.

It will go wrong, if the static "thingMap" field would have an
initializing expression, e.g.
(A) private static Map<String, Thing> thingMap = null;
or
(B) private static Map<String, Thing> thingMap = new HashMap<String,
Thing>();

Then step 2a would execute the initializing expression, assigning an new
object to "thingMap", and discarding the map created in step 1a.
Step 2b then would throw a NullPointer exception in case of
initializing expression (A). In case (B), the "things" field would refer
to an (unmodifiable) empty map.
--
Regards,

Roland