Home How can I initialise a static Map?
Reply: 27

How can I initialise a static Map?

dogbane Published in 2009-02-03 15:41:33Z

How would you initialise a static Map in Java?

Method one: static initialiser
Method two: instance initialiser (anonymous subclass) or some other method?

What are the pros and cons of each?

Here is an example illustrating two methods:

import java.util.HashMap;
import java.util.Map;

public class Test {
    private static final Map<Integer, String> myMap = new HashMap<Integer, String>();
    static {
        myMap.put(1, "one");
        myMap.put(2, "two");

    private static final Map<Integer, String> myMap2 = new HashMap<Integer, String>(){
            put(1, "one");
            put(2, "two");
Outlaw Programmer
Outlaw Programmer Reply to 2015-02-25 16:06:25Z

The instance initialiser is just syntactic sugar in this case, right? I don't see why you need an extra anonymous class just to initialize. And it won't work if the class being created is final.

You can create an immutable map using a static initialiser too:

public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);
Mark Renouf
Mark Renouf Reply to 2009-02-03 15:45:34Z

The second method could invoke protected methods if needed. This can be useful for initializing classes which are immutable after construction.

eljenso Reply to 2009-02-04 08:19:39Z

I would never create an anonymous subclass in this situation. Static initializers work equally well, if you would like to make the map unmodifiable for example:

private static final Map<Integer, String> MY_MAP;
    Map<Integer, String>tempMap = new HashMap<Integer, String>();
    tempMap.put(1, "one");
    tempMap.put(2, "two");
    MY_MAP = Collections.unmodifiableMap(tempMap);
Chase Seibert
Chase Seibert Reply to 2009-02-03 16:18:07Z

I like the anonymous class syntax; it's just less code. However, one major con I have found is that you won't be able to serialize that object via remoting. You will get an exception about not being able to find the anonymous class on the remote side.

Brian Agnew
Brian Agnew Reply to 2009-02-04 10:21:17Z

The anonymous class you're creating works well. However you should be aware that this is an inner class and as such, it'll contain a reference to the surrounding class instance. So you'll find you can't do certain things with it (using XStream for one). You'll get some very strange errors.

Having said that, so long as you're aware then this approach is fine. I use it most of the time for initialising all sorts of collections in a concise fashion.

EDIT: Pointed out correctly in the comments that this is a static class. Obviously I didn't read this closely enough. However my comments do still apply to anonymous inner classes.

Gary Kephart
Gary Kephart Reply to 2009-02-03 18:40:56Z

I've done something a bit different. Not the best, but it works for me. Maybe it could be "genericized".

private static final Object[][] ENTRIES =
  {new Integer(1), "one"},
  {new Integer(2), "two"},
private static final Map myMap = newMap(ENTRIES);

private static Map newMap(Object[][] entries)
  Map map = new HashMap();

  for (int x = 0; x < entries.length; x++)
    Object[] entry = entries[x];

    map.put(entry[0], entry[1]);

  return map;
Paŭlo Ebermann
Paŭlo Ebermann Reply to 2014-01-29 20:27:52Z

Maybe it's interesting to check out Google Collections, e.g. the videos that they have on their page. They provide various ways to initialize maps and sets, and provide immutable collections as well.

Update: This library is now named Guava.

Peter Štibraný
Peter Štibraný Reply to 2009-02-03 21:40:14Z

I would use:

public class Test {
    private static final Map<Integer, String> MY_MAP = createMap();

    private static Map<Integer, String> createMap() {
        Map<Integer, String> result = new HashMap<Integer, String>();
        result.put(1, "one");
        result.put(2, "two");
        return Collections.unmodifiableMap(result);
  1. it avoids anonymous class, which I personally consider to be a bad style, and avoid
  2. it makes creation of map more explicit
  3. it makes map unmodifiable
  4. as MY_MAP is constant, I would name it like constant
Chris Noe
Chris Noe Reply to 2009-07-15 21:29:54Z

Java 5 provides this more compact syntax:

static final Map<String , String> FLAVORS = new HashMap<String , String>() {{
    put("Up",    "Down");
    put("Charm", "Strange");
    put("Top",   "Bottom");
Leninkumar Koppoju
Leninkumar Koppoju Reply to 2010-06-03 08:30:03Z
public class Test {
    private static final Map<Integer, String> myMap;
    static {
        Map<Integer, String> aMap = ....;
        aMap.put(1, "one");
        aMap.put(2, "two");
        myMap = Collections.unmodifiableMap(aMap);

If we declare more than one constant then that code will be written in static block and that is hard to maintain in future. So it is better to use anonymous class.

public class Test {

    public static final Map numbers = Collections.unmodifiableMap(new HashMap(2, 1.0f){
            put(1, "one");
            put(2, "two");

And it is suggested to used unmodifiableMap for constants other wise it can't be treated as constant.

Dennis C
Dennis C Reply to 2010-12-12 04:29:03Z

I could strongly suggest the "double brace initialization" style over static block style.

Someone may comment that they don't like anonymous class, overhead, performance, etc.

But that I more consider is the code readability and maintainability. In this point of view, I stand a double brace is a better code style rather then static method.

  1. The elements are nested and inline.
  2. It is more OO, not procedural.
  3. the performance impact is really small and could be ignored.
  4. Better IDE outline support (rather then many anonymous static{} block)
  5. You saved few lines of comment to bring them relationship.
  6. Prevent possible element leak/instance lead of uninitialized object from exception and bytecode optimizer.
  7. No worry about the order of execution of static block.

In addition, it you aware the GC of the anonymous class, you can always convert it to a normal HashMap by using new HashMap(Map map).

You can do this until you faced another problem. If you do, you should use complete another coding style (e.g. no static, factory class) for it.

Community Reply to 2017-05-23 12:10:45Z

I like the Guava way of initialising a static, immutable map:

static final Map<Integer, String> MY_MAP = ImmutableMap.of(
    1, "one",
    2, "two"

As you can see, it's very concise (because of the convenient factory methods in ImmutableMap).

If you want the map to have more than 5 entries, you can no longer use ImmutableMap.of(). Instead, try ImmutableMap.builder() along these lines:

static final Map<Integer, String> MY_MAP = ImmutableMap.<Integer, String>builder()
    .put(1, "one")
    .put(2, "two")
    // ... 
    .put(15, "fifteen")

To learn more about the benefits of Guava's immutable collection utilities, see Immutable Collections Explained in Guava User Guide.

(A subset of) Guava used to be called Google Collections. If you aren't using this library in your Java project yet, I strongly recommend trying it out! Guava has quickly become one of the most popular and useful free 3rd party libs for Java, as fellow SO users agree. (If you are new to it, there are some excellent learning resources behind that link.)

Update (2015): As for Java 8, well, I would still use the Guava approach because it is way cleaner than anything else. If you don't want Guava dependency, consider a plain old init method. The hack with two-dimensional array and Stream API is pretty ugly if you ask me, and gets uglier if you need to create a Map whose keys and values are not the same type (like Map<Integer, String> in the question).

As for future of Guava in general, with regards to Java 8, Louis Wasserman said this back in 2014, and [update] in 2016 it was announced that Guava 21 will require and properly support Java 8.

Update (2016): As Tagir Valeev points out, Java 9 will finally make this clean to do using nothing but pure JDK, by adding convenience factory methods for collections:

static final Map<Integer, String> MY_MAP = Map.of(
    1, "one", 
    2, "two"
Stanisław Borowy
Stanisław Borowy Reply to 2012-08-28 07:00:27Z

I do not like Static initializer syntax and I'm not convinced to anonymous subclasses. Generally, I agree with all cons of using Static initializers and all cons of using anonymous subclasses that were mentioned in previus answers. On the other hand - pros presented in these posts are not enough for me. I prefer to use static initialization method:

public class MyClass {
    private static final Map<Integer, String> myMap = prepareMap();

    private static Map<Integer, String> prepareMap() {
        Map<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1, "one");
        hashMap.put(2, "two");

        return hashMap;
Donald Raab
Donald Raab Reply to 2017-02-13 18:47:53Z

With Eclipse Collections (formerly GS Collections), all of the following will work:

import java.util.Map;

import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.factory.Maps;

public class StaticMapsTest
    private static final Map<Integer, String> MAP =
        Maps.mutable.with(1, "one", 2, "two");

    private static final MutableMap<Integer, String> MUTABLE_MAP =
       Maps.mutable.with(1, "one", 2, "two");

    private static final MutableMap<Integer, String> UNMODIFIABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").asUnmodifiable();

    private static final MutableMap<Integer, String> SYNCHRONIZED_MAP =
        Maps.mutable.with(1, "one", 2, "two").asSynchronized();

    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").toImmutable();

    private static final ImmutableMap<Integer, String> IMMUTABLE_MAP2 =
        Maps.immutable.with(1, "one", 2, "two");

You can also statically initialize primitive maps with Eclipse Collections.

import org.eclipse.collections.api.map.primitive.ImmutableIntObjectMap;
import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
import org.eclipse.collections.impl.factory.primitive.IntObjectMaps;

public class StaticPrimitiveMapsTest
    private static final MutableIntObjectMap<String> MUTABLE_INT_OBJ_MAP =
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two");

    private static final MutableIntObjectMap<String> UNMODIFIABLE_INT_OBJ_MAP =
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")

    private static final MutableIntObjectMap<String> SYNCHRONIZED_INT_OBJ_MAP =
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP =
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP2 =
                    .newWithKeyValue(1, "one")
                    .newWithKeyValue(2, "two");

Note: I am a committer for Eclipse Collections

Philip Reply to 2013-08-06 20:35:48Z

If you want something terse and relatively safe, you can just shift compile-time type checking to run-time:

static final Map<String, Integer> map = MapUtils.unmodifiableMap(
    String.class, Integer.class,
    "cat",  4,
    "dog",  2,
    "frog", 17

This implementation should catch any errors:

import java.util.HashMap;

public abstract class MapUtils
    private MapUtils() { }

    public static <K, V> HashMap<K, V> unmodifiableMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
        return Collections.<K, V>unmodifiableMap(makeMap(

    public static <K, V> HashMap<K, V> makeMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
        if (keyValues.length % 2 != 0)
            throw new IllegalArgumentException(
                    "'keyValues' was formatted incorrectly!  "
                  + "(Expected an even length, but found '" + keyValues.length + "')");

        HashMap<K, V> result = new HashMap<K, V>(keyValues.length / 2);

        for (int i = 0; i < keyValues.length;)
            K key = cast(keyClazz, keyValues[i], i);
            V val = cast(valClazz, keyValues[i], i);
            result.put(key, val);

        return result;

    private static <T> T cast(Class<? extends T> clazz, Object object, int i)
            return clazz.cast(object);
        catch (ClassCastException e)
            String objectName = (i % 2 == 0) ? "Key" : "Value";
            String format = "%s at index %d ('%s') wasn't assignable to type '%s'";
            throw new IllegalArgumentException(String.format(format, objectName, i, object.toString(), clazz.getSimpleName()), e);
peterh Reply to 2016-04-28 06:12:40Z

I like anonymous class, because it is easy to deal with it:

public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() {
        put(1, "some value");
                    //rest of code here
icza Reply to 2015-12-08 23:00:31Z

If you can use a String representation of your data this is an option too in Java 8:

static Map<Integer, String> MAP = Stream.of(
).collect(Collectors.toMap(k -> Integer.parseInt(k.split("=")[0]), v -> v.split("=")[1]));
Jonik Reply to 2015-12-08 22:45:57Z

Here's a Java 8 one-line static map initializer:

private static final Map<String, String> EXTENSION_TO_MIMETYPE =
    Arrays.stream(new String[][] {
        { "txt", "text/plain" }, 
        { "html", "text/html" }, 
        { "js", "application/javascript" },
        { "css", "text/css" },
        { "xml", "application/xml" },
        { "png", "image/png" }, 
        { "gif", "image/gif" }, 
        { "jpg", "image/jpeg" },
        { "jpeg", "image/jpeg" }, 
        { "svg", "image/svg+xml" },
    }).collect(Collectors.toMap(kv -> kv[0], kv -> kv[1]));

Edit: to initialize a Map<Integer, String> as in the question, you'd need something like this:

static final Map<Integer, String> MY_MAP = Arrays.stream(new Object[][]{
        {1, "one"},
        {2, "two"},
}).collect(Collectors.toMap(kv -> (Integer) kv[0], kv -> (String) kv[1]));
Jim Daehn
Jim Daehn Reply to 2015-01-28 21:41:05Z

I like using the static initializer "technique" when I have a concrete realization of an abstract class that has defined an initializing constructor but no default constructor but I want my subclass to have a default constructor.

For example:

public abstract class Shape {

    public static final String COLOR_KEY = "color_key";
    public static final String OPAQUE_KEY = "opaque_key";

    private final String color;
    private final Boolean opaque;

     * Initializing constructor - note no default constructor.
     * @param properties a collection of Shape properties
    public Shape(Map<String, Object> properties) {
        color = ((String) properties.getOrDefault(COLOR_KEY, "black"));
        opaque = (Boolean) properties.getOrDefault(OPAQUE_KEY, false);

     * Color property accessor method.
     * @return the color of this Shape
    public String getColor() {
        return color;

     * Opaque property accessor method.
     * @return true if this Shape is opaque, false otherwise
    public Boolean isOpaque() {
        return opaque;

and my concrete realization of this class -- but it wants/needs a default constructor:

public class SquareShapeImpl extends Shape {

    private static final Map<String, Object> DEFAULT_PROPS = new HashMap<>();

    static {
        DEFAULT_PROPS.put(Shape.COLOR_KEY, "yellow");
        DEFAULT_PROPS.put(Shape.OPAQUE_KEY, false);

     * Default constructor -- intializes this square to be a translucent yellow
    public SquareShapeImpl() {
        // the static initializer was useful here because the call to 
        // this(...) must be the first statement in this constructor
        // i.e., we can't be mucking around and creating a map here

     * Initializing constructor -- create a Square with the given
     * collection of properties.
     * @param props a collection of properties for this SquareShapeImpl
    public SquareShapeImpl(Map<String, Object> props) {

then to use this default constructor, we simply do:

public class StaticInitDemo {

    public static void main(String[] args) {

        // create a translucent, yellow square...
        Shape defaultSquare = new SquareShapeImpl();

        // etc...
Vlasec Reply to 2016-04-12 17:33:50Z

I've read the answers and i decided to write my own map builder. Feel free to copy-paste and enjoy.

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

 * A tool for easy creation of a map. Code example:<br/>
 * {@code MapBuilder.of("name", "Forrest").and("surname", "Gump").build()}
 * @param <K> key type (inferred by constructor)
 * @param <V> value type (inferred by constructor)
 * @author Vlasec (for http://stackoverflow.com/a/30345279/1977151)
public class MapBuilder <K, V> {
    private Map<K, V> map = new HashMap<>();

    /** Constructor that also enters the first entry. */
    private MapBuilder(K key, V value) {
        and(key, value);

    /** Factory method that creates the builder and enters the first entry. */
    public static <A, B> MapBuilder<A, B> of(A key, B value) {
        return new MapBuilder<>(key, value);

    /** Puts the key-value pair to the map and returns itself for method chaining */
    public MapBuilder<K, V> and(K key, V value) {
        map.put(key, value);
        return this;

     * If no reference to builder is kept and both the key and value types are immutable,
     * the resulting map is immutable.
     * @return contents of MapBuilder as an unmodifiable map.
    public Map<K, V> build() {
        return Collections.unmodifiableMap(map);

EDIT: Lately, I keep finding public static method of pretty often and I kinda like it. I added it into the code and made the constructor private, thus switching to static factory method pattern.

josh Reply to 2015-06-03 20:46:29Z

I have not seen the approach I use (and have grown to like) posted in any answers, so here it is:

I don't like using static initializers because they are clunky, and I don't like anonymous classes because it is creating a new class for each instance.

instead, I prefer initialization that looks like this:

    entry("keyA", "val1"),
    entry("keyB", "val2"),
    entry("keyC", "val3")

unfortunately, these methods are not part of the standard Java library, so you will need to create (or use) a utility library that defines the following methods:

 public static <K,V> Map<K,V> map(Map.Entry<K, ? extends V>... entries)
 public static <K,V> Map.Entry<K,V> entry(K key, V val)

(you can use 'import static' to avoid needing to prefix the method's name)

I found it useful to provide similar static methods for the other collections (list, set, sortedSet, sortedMap, etc.)

Its not quite as nice as json object initialization, but it's a step in that direction, as far as readability is concerned.

Tomáš Záluský
Tomáš Záluský Reply to 2015-08-06 16:10:30Z

In Java 8, procedural approach can also be wrapped in Supplier:

Map<String,String> m = ((Supplier<Map<String,String>>)(() -> {
    Map<String,String> result = new HashMap<>();
    return result;

It's only hypothetical way but can come handy if you really need one-liner.

agad Reply to 2016-11-28 07:47:53Z

As usual apache-commons has proper method MapUtils.putAll(Map, Object[]):

For example, to create a color map:

Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}
zrvan Reply to 2016-06-23 09:14:04Z

With Java 8 I've come to use the following pattern:

private static final Map<String, Integer> MAP = Stream.of(
    new AbstractMap.SimpleImmutableEntry<>("key1", 1),
    new AbstractMap.SimpleImmutableEntry<>("key2", 2)
).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

It's not the most terse and a bit roundabout, but

  • it doesn't require anything outside of java.util
  • it's typesafe and easily accommodates different types for key and value.
Jonik Reply to 2017-10-24 23:11:21Z

In Java 9:

private static final Map<Integer, String> MY_MAP = Map.of(1, "one", 2, "two");

See JEP 269 for details. JDK 9 reached general availability in September 2017.

Jason Reply to 2016-01-28 16:20:21Z

There are some good answers here, but I do want to offer one more.

Create your own static method to create and initialize a Map. I have my own CollectionUtils class in a package that I use across projects with various utilities that I use regularly that are easy for me to write and avoids the need for a dependency on some larger library.

Here's my newMap method:

public class CollectionUtils {
    public static Map newMap(Object... keyValuePairs) {
        Map map = new HashMap();
        if ( keyValuePairs.length % 2 == 1 ) throw new IllegalArgumentException("Must have even number of arguments");
        for ( int i=0; i<keyValuePairs.length; i+=2 ) {
            map.put(keyValuePairs[i], keyValuePairs[i + 1]);
        return map;


import static CollectionUtils.newMap;
// ...
Map aMap = newMap("key1", 1.23, "key2", 2.34);
Map bMap = newMap(objKey1, objVal1, objKey2, objVal2, objKey3, objVal3);
// etc...

It doesn't make use of generics, but you can typecast the map as you wish (just be sure you typecast it correctly!)

Map<String,Double> aMap = (Map<String,Double>)newMap("key1", 1.23, "key2", 2.34);
nazar_art Reply to 2016-02-26 21:53:35Z

Because Java does not support map literals, map instances must always be explicitly instantiated and populated.

Fortunately, it is possible to approximate the behavior of map literals in Java using factory methods.

For example:

public class LiteralMapFactory {

    // Creates a map from a list of entries
    public static <K, V> Map<K, V> mapOf(Map.Entry<K, V>... entries) {
        LinkedHashMap<K, V> map = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : entries) {
            map.put(entry.getKey(), entry.getValue());
        return map;
    // Creates a map entry
    public static <K, V> Map.Entry<K, V> entry(K key, V value) {
        return new AbstractMap.SimpleEntry<>(key, value);

    public static void main(String[] args) {
        System.out.println(mapOf(entry("a", 1), entry("b", 2), entry("c", 3)));


{a=1, b=2, c=3}

It is a lot more convenient than creating and populating the map an element at a time.

You need to login account before you can post.

About| Privacy statement| Terms of Service| Advertising| Contact us| Help| Sitemap|
Processed in 0.434136 second(s) , Gzip On .

© 2016 Powered by mzan.com design MATCHINFO