New instance of a static HashMap

[Rebecca Peltz]

I have some fixed data that I'm loading into a static hash map. This data will then be manipulated and vary per user in JSP, so I create an instance of the Hashmap from the static Hashmap.

public static Map<Integer, String> theMap= new HashMap<Integer,String>();  //create static map

later in JSP create an instance

Map<Integer,String> aMap=  new HashMap(theMap); //create an instance

I just want to verify that I am truly getting an instance of the static data on the heap.

[Joe Areeda]

Rebecca,

That's a good question. I know you're getting a HashMap on the heap but I'm not sure if you're getting clones of the objects in the Map or references to the originals.

It is easy to test in a debugger.

You can check the refernces to the Strings.

I'm not sure it really matters as replacing items in the copy of the hash map should not affect those in the static one.

Please let us know the results if you do that experiment.

Joe

[Steve Luke]

You are getting a new HashMap, which is a copy of the original HashMap. The values in the new Map are the exact Objects in the original, but that should not be a problem because the types are Integer and String, which are both immutable.

There is a problem with your terminology, though. There is no such thing as a 'static HashMap' and you are not creating an instance of it. Rather, you have a static variable which points to a HashMap and you are creating a new copy of that HashMap.

[Joe Areeda]

Thanks Steve,
That cleared up my confusion. I forgot Integer and String (and all the other objects representing basic types) were immutable.

Joe

[Campbell Ritchie]

You might do better to create an un‑modifiable Map.

public class Foo
{
   private final Map<String, Integer> myMap = createMap();

   public static Map<String, Integer> getMap()
   {
       return myMap;
   }

   private static Map<String, Integer> createMap()
   {
      Map<String, Integer> map = new HashMap<>(); // Before Java7, you had to write <String, Integer>
      map.put("Campbell", 123);
      map.put("Rebecca", 234);
      map.put("Joe", 345);
      return java.util.Collections.unmodifiableMap(map);
   }

/*
 * Please threading experts check there is no risk of your letting the Map reference
 * escape before all its values have been put.
 */
// etc
}

[Rebecca Peltz]

I checked the string references in the debugger and they were different, so my method works. I like the suggested method - and didn't realize that a static could return a final instance.

[Tony Docherty]

I checked the string references in the debugger and they were different, so my method works

As Steve has already pointed out it wouldn't matter if the references were the same or not. Integer and String objects are immutable and so can't be edited, therefore, even if the user changes one of the values in the copy it won't affect the original in any way.