How can I initialise a static Map?

Question

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 the two methods:

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

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

    private static final Map<Integer, String> myMap2 = new HashMap<>(){
        {
            put(1, "one");
            put(2, "two");
        }
    };
}

Skaw

For initializing a map in Java 8: https://mcmap.net/q/45459/-how-can-i-initialise-a-static-map – Hertford

Please, never use double brace initialization - it's a hack, and an easy way to leak memory and cause other problems. – Sim

Java 9? If entries count <= 10 use Map.of else Map.ofEntries, check https://mcmap.net/q/45459/-how-can-i-initialise-a-static-map – Hertford

Answer 1

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);
    }
}

Colmar

This is the idiom I've used for years and I've never had anyone bat an eye at it. I do the same for unmodifiable constant Sets and Lists too. – Aristides

How would I handle a HashMap<String, String> with a String key. The Map object doesn't allow me to have a String key so I can't use unmodifiableMap(). I guess casting to a HashMap would defeat the purpose as well. Any ideas? – Sift

@Sift of course the Map object allows you to use a String key. I've used the above idiom many times with Map<String, String>. – Halflife

@mluisbrown: Maybe it is an Android limitation (I forgot to mention that), as it won't let me use a String key for a Map object in an Android app. – Sift

@Sift I seriously doubt that Android has such a limitation. It makes no sense at all. A quick search found this question here (and many others) which seems to imply you can use a String key for a Map object in Android. – Halflife

So no one else bothers to investigate, I can confirm there's no problem with using a String key for a Map object on Android. – Stork

Jordan: it is an old topic now but I suspect @Sift was trying to use a string as a key in a map that had a different key type, e.g. Map<Integer, String>. – Colmar

what is use of creating map inside static block, static reference created outside of static block can be used? could you please explain? – Phototransistor

In this case, the reason for creating a local map inside the static block is to eventually convert it to an unmodifiableMap, so that Test.myMap is unmodifiable. I do not understand what you mean by "eference created outside of static block can be used" – Colmar

Answer 2

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")
    .build();

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"
);

Dustheap

Seems like our fellow SO admins have deleted the venerable "Most useful free third party Java libraries" question to which I linked. :( Damn them. – Dustheap

I agree, this is the nicest way of initializing a constant map. Not only more readable but also since Collections.unmodifiableMap returns a read-only view of the underlying map (that still can be modified). – Leeannaleeanne

I can now see deleted questions (with 10k+ rep), so here's a copy of 'Most useful free third-party Java libraries'. It's only the first page, but at least you can find the Guava resources mentioned above. – Dustheap

I really prefer this approach, although it's beneficial to know how to do it without extra dependencies. – Stephaniestephannie

JEP 186 still not closed, so it may introduce new features related to collection literals – Kunstlied

Instead of lazily using unmodifiable maps (which are mostlikely "stringly-typed"), consider creating a proper Class or Enum / EnumSet. – Warfeld

My only complaint with the ImmutableMap.of(...) approach is it can't possibly be type safe, unless the library specifically hard-coded static methods with varying length arguments. Which I guess is why it only worked up to 5 entries. It looks like Java 9 will have that same limitation with the convenience factory methods (but maybe more, e.g. 10 entries). However they mention static factory methods for Map.Entry so you can do arbitrary length: Map.ofEntries(entry(k1, v1), ...) – Inurn

The Java 9 method is clean and all, until you realize how it was implemented – Flung

Answer 3

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<>();
        result.put(1, "one");
        result.put(2, "two");
        return Collections.unmodifiableMap(result);
    }
}

1. it avoids an anonymous class, which I personally consider to be a bad style, and avoid
2. it makes the creation of map more explicit
3. it makes map unmodifiable
4. as MY_MAP is constant, I would name it like constant

Sphacelus

Of the pure JDK options (no libs), I like this the most, because map definition is clearly linked to its initialisation. Also agreed on constant naming. – Dustheap

It never occurred to me that you could do this. – Acolyte

Answer 4

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");
}};

Jawbone

That technique is called double brace initialization: #1372613 It's not a special Java 5 syntax, it's just a trick with an anonymous class with an instance initializer. – Throes

Quick question regarding the double brace initialization: When doing this, Eclipse issues a Warning about a missing Serial ID. On one hand, I don't see why a Serial ID would be needed in this specific case, but on the other hand, I usually don't like supressing warnings. What are your thoughts on this? – Libeler

@Libeler That's because HashMap implements Serializable. Since you actually create a subclass of HashMap using this "trick", you implicitly creating a Serializable class. And for this you should supply a serialUID. – Preface

Double brace initialization can cause memory leaks when used from a non-static context, because the anonymous class created will maintain a reference to the surrounding object. It has worse performance than regular initialization because of the additional class loading required. It can cause equals() comparisons to fail, if the equals() method does not accept subclasses as parameter. And finally, pre Java 9 it cannot be combined with the diamond operator, because that cannot be used with anonymous classes. – IntelliJ – Aggrieve

@MarkJeronimus Diamond operator can be used with anonymous inner classes in Java9. – Cumings

@MarkJeronimus - The suggested use is a static context. The performance may be worse, but not noticeably so when dealing with a presumably small number of statically defined maps. HashMap.equals is defined in AbstractMap and works on any subclass of Map, so that isn't a concern here. The diamond operator thing is annoying, but as mentioned has now been resolved. – Globigerina

SonarLint complains about Double brace initialization because it can lead to memory leak. – Therapsid

@Libeler "missing Serial ID" is one of few warnings I switched off. I'd recommend everyone to do the same, unless (1) they use Java serialization (not recommended), (2) they persist their Serializables and (3) are willing to maintain compatibility of the serialized form. When any of the conditions is false, then you need no serialUUID. Especially, when only (1) and (2) hold, the default ("missing") serialUUID is perfect. – Tungsten

Answer 5

One advantage to the second method is that you can wrap it with Collections.unmodifiableMap() to guarantee that nothing is going to update the collection later:

private static final Map<Integer, String> CONSTANT_MAP = 
    Collections.unmodifiableMap(new HashMap<Integer, String>() {{ 
        put(1, "one");
        put(2, "two");
    }});

 // later on...

 CONSTANT_MAP.put(3, "three"); // going to throw an exception!

Orjonikidze

Can't you easily do this in the first method by moving the new operator into the static {} block and wrapping it? – Lachrymator

I'd move the constructor call into the static initialised anyway. Anything else just looks odd. – Artamas

any idea what performance hit there might be from using an anonymous class as opposed to a concrete class? – Feriga

Answer 6

Map.of 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.

Microcurie

Or if you want more than 10 key-value pairs, you can use Map.ofEntries – Clover

This is clean and all, until you realize how it was implemented – Flung

Ugh thats so sad - looks like it only supports 10 entries, after which you need to use ofEntries. Lame. – Gleason

The implementation cleanliness in the JDK shouldn't matter as long as it works and satisfies the contract. Like any black box, implementation details can always be fixed in future if really needed... – Abomb

@Flung That's the only typesafe way to do this in Java. – Tunnage

@LukeHutchison I wouldn't say a library has to be clean internally. – Flung

@Flung I agree. Well the maximum number of parameters in a Java method is 255, so technically you could only go as high as 128 key-value pairs in this way, while supporting type safety. The real problem here is that arrays are not able to be made generic, so you can't declare a varargs type like Map.of(Entry<Integer, String>...). – Tunnage

For more than 10 entries, see this Answer on this same page, using Map.ofEntries. – Infidelity

Answer 7

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]));

Edit(2): There is a better, mixed-type-capable version by i_am_zero that uses a stream of new SimpleEntry<>(k, v) calls. Check out that answer: https://mcmap.net/q/45459/-how-can-i-initialise-a-static-map

Tunnage

I took the liberty to add a version that is equivalent with the question and other answers: init a Map whose keys and values are of different type (so String[][] won't do, Object[][] is needed). IMHO, this approach is ugly (even more so with the casts) and hard to remember; wouldn't use it myself. – Dustheap

Answer 8

Java 9

We can use Map.ofEntries, calling Map.entry( k , v ) to create each entry.

import static java.util.Map.entry;
private static final Map<Integer,String> map = Map.ofEntries(
        entry(1, "one"),
        entry(2, "two"),
        entry(3, "three"),
        entry(4, "four"),
        entry(5, "five"),
        entry(6, "six"),
        entry(7, "seven"),
        entry(8, "eight"),
        entry(9, "nine"),
        entry(10, "ten"));

We can also use Map.of as suggested by Tagir in his answer here but we cannot have more than 10 entries using Map.of.

Java 8

We can create a Stream of map entries. We already have two implementations of Entry in java.util.AbstractMap which are SimpleEntry and SimpleImmutableEntry. For this example we can make use of former as:

import java.util.AbstractMap.*;
private static final Map<Integer, String> myMap = Stream.of(
            new SimpleEntry<>(1, "one"),
            new SimpleEntry<>(2, "two"),
            new SimpleEntry<>(3, "three"),
            new SimpleEntry<>(4, "four"),
            new SimpleEntry<>(5, "five"),
            new SimpleEntry<>(6, "six"),
            new SimpleEntry<>(7, "seven"),
            new SimpleEntry<>(8, "eight"),
            new SimpleEntry<>(9, "nine"),
            new SimpleEntry<>(10, "ten"))
            .collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));
            

Hertford

The new SimpleEntry<>() way is far less readable than static put() :/ – Dome

Answer 9

With Eclipse 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 =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two");

    private static final MutableIntObjectMap<String> UNMODIFIABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asUnmodifiable();

    private static final MutableIntObjectMap<String> SYNCHRONIZED_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asSynchronized();

    private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.<String>empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .toImmutable();

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

Note: I am a committer for Eclipse Collections

Strangles

I really wish Eclipse Collections was the default collections library for Java. I enjoy it so much more than Guava + JCL. – Burroughs

Answer 10

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;
static
{
    Map<Integer, String>tempMap = new HashMap<Integer, String>();
    tempMap.put(1, "one");
    tempMap.put(2, "two");
    MY_MAP = Collections.unmodifiableMap(tempMap);
}

Lazare

In which situation would you use an anonymous subclass to initialise a hashmap then? – Skaw

Never to initialize a Collection. – Lazare

Could you explain why using a static initializer is a better choice than creating an anonymous subclass? – Apocarp

@rookie There are several reasons given in other answers favoring the static init. The goal here is to initialize, so why bring in the subclassing, except maybe to save a few keystrokes? (If you want to save on keystrokes, Java is definitely not a good choice as a programming language.) One rule of thumb I use when programming in Java is: subclass as little as possible (and never when it can be reasonably avoided). – Lazare

@Lazare - the reason I generally favour the subclass syntax for this is that it puts the initialisation inline, where it belongs. A second-best choice is to call a static method that returns the initialised map. But I'm afraid I'd look at your code and have to spend a few seconds working out where MY_MAP comes from, and that's time that I don't want to have to waste. Any improvement to readability is a bonus, and the performance consequences are minimal, so it seems like the best option to me. – Globigerina

You can't use a methods parameter in a static initiializer. – Dome

Answer 11

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
    }
});

Vida

Answer 12

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.

Solitude

Answer 13

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.

Cottar

Answer 14

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.

Figge

Answer 15

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"}
 });

Coraciiform

I include Apache Commons in all builds so, in the unfortunate absence of a method Arrays.asMap( ... ) in plain Java, I think this is the best solution. Reinventing the wheel is usually silly. Very slight downside is that with generics it will need an unchecked conversion. – Lento

@mikerodent 4.1 version is generic: public static <K, V> Map<K, V> putAll(final Map<K, V> map, final Object[] array) – Coraciiform

Tx ... yes, I'm using 4.1 but I still have to SuppressWarnings( unchecked ) in Eclipse with a line like Map<String, String> dummy = MapUtils.putAll(new HashMap<String, String>(), new Object[][]... ) – Lento

@mikerodent isn't it because of Object[][]? See updated unswear - I don't have any warning in Eclipse. – Coraciiform

How strange... even when I go String[][] I get the "warning"! And of course that only works if your K and V are the same class. I take it you haven't (understandably) set "unchecked conversion" to "Ignore" in your Eclipse setup? – Lento

@mikerodent I don't have annotation and "Unchecked generic type operation" is set to warning. Removing types from HashMap, causes warning to appear. – Coraciiform

My Eclipse is Mars.2 build 4.5.2. Or could it be a Java version difference? I'm using 1.8.0_91 as my Eclipse JRE. Otherwise I give up: mystery! – Lento

@mikerodent I have Neon Release (4.6.0) and jdk1.8.0_74 – Coraciiform

Answer 16

Here's my favorite if I

• don't want to (or cannot) use Guava's ImmutableMap.of()
• or I need a mutable Map
• or I need more than the 10 entry limit in Map.of() from JDK9+

public static <A> Map<String, A> asMap(Object... keysAndValues) {
  return new LinkedHashMap<String, A>() {{
    for (int i = 0; i < keysAndValues.length - 1; i++) {
      put(keysAndValues[i].toString(), (A) keysAndValues[++i]);
    }
  }};
}

It's very compact, and it ignores stray values (i.e. a final key without a value).

Usage:

Map<String, String> one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal");
Map<String, Object> two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2));

Samos

Answer 17

I prefer using a static initializer to avoid generating anonymous classes (which would have no further purpose), so I'll list tips initializing with a static initializer. All listed solutions / tips are type-safe.

Note: The question doesn't say anything about making the map unmodifiable, so I will leave that out, but know that it can easily be done with Collections.unmodifiableMap(map).

First tip

The 1st tip is that you can make a local reference to the map and you give it a SHORT name:

private static final Map<Integer, String> myMap = new HashMap<>();
static {
    final Map<Integer, String> m = myMap; // Use short name!
    m.put(1, "one"); // Here referencing the local variable which is also faster!
    m.put(2, "two");
    m.put(3, "three");
}

Second tip

The 2nd tip is that you can create a helper method to add entries; you can also make this helper method public if you want to:

private static final Map<Integer, String> myMap2 = new HashMap<>();
static {
    p(1, "one"); // Calling the helper method.
    p(2, "two");
    p(3, "three");
}

private static void p(Integer k, String v) {
    myMap2.put(k, v);
}

The helper method here is not re-usable though because it can only add elements to myMap2. To make it re-usable, we could make the map itself a parameter of the helper method, but then initialization code would not be any shorter.

Third tip

The 3rd tip is that you can create a re-usable builder-like helper class with the populating functionality. This is really a simple, 10-line helper class which is type-safe:

public class Test {
    private static final Map<Integer, String> myMap3 = new HashMap<>();
    static {
        new B<>(myMap3)   // Instantiating the helper class with our map
            .p(1, "one")
            .p(2, "two")
            .p(3, "three");
    }
}

class B<K, V> {
    private final Map<K, V> m;

    public B(Map<K, V> m) {
        this.m = m;
    }

    public B<K, V> p(K k, V v) {
        m.put(k, v);
        return this; // Return this for chaining
    }
}

Plus

Answer 18

If you want unmodifiable map, finally java 9 added a cool factory method of to Map interface. Similar method is added to Set, List as well.

Map<String, String> unmodifiableMap = Map.of("key1", "value1", "key2", "value2");

Markel

Answer 19

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.

Quamash

In this particular case it's static, so no outer instance. – Artamas

Arguably XStream shouldn't be trying to serialize stuff like this (it's static. Why would you need to serialize a static variable?) – Aristides

Answer 20

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,
            Object...keyValues)
    {
        return Collections.<K, V>unmodifiableMap(makeMap(
            keyClazz,
            valClazz,
            keyValues));
    }

    public static <K, V> HashMap<K, V> makeMap(
            Class<? extends K> keyClazz,
            Class<? extends V> valClazz,
            Object...keyValues)
    {
        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);
            ++i;
            V val = cast(valClazz, keyValues[i], i);
            ++i;
            result.put(key, val);
        }

        return result;
    }

    private static <T> T cast(Class<? extends T> clazz, Object object, int i)
    {
        try
        {
            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);
        }
    }
}

Snocat

Answer 21

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.

Euchromosome

if needed, one can use the toMap signature including a map supplier to specify the type of map. – Euchromosome

Answer 22

If you only need to add one value to the map you can use Collections.singletonMap:

Map<K, V> map = Collections.singletonMap(key, value)

Stephi

Answer 23

Your second approach (Double Brace initialization) is thought to be an anti pattern, so I would go for the first approach.

Another easy way to initialise a static Map is by using this utility function:

public static <K, V> Map<K, V> mapOf(Object... keyValues) {
    Map<K, V> map = new HashMap<>(keyValues.length / 2);

    for (int index = 0; index < keyValues.length / 2; index++) {
        map.put((K)keyValues[index * 2], (V)keyValues[index * 2 + 1]);
    }

    return map;
}

Map<Integer, String> map1 = mapOf(1, "value1", 2, "value2");
Map<String, String> map2 = mapOf("key1", "value1", "key2", "value2");

Note: in Java 9 you can use Map.of

Hemp

Answer 24

You may use StickyMap and MapEntry from Cactoos:

private static final Map<String, String> MAP = new StickyMap<>(
  new MapEntry<>("name", "Jeffrey"),
  new MapEntry<>("age", "35")
);

Sophey

Answer 25

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;
    }
}

Roebuck

Answer 26

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:

map(
    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.

Filmore

Answer 27

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
    @SafeVarargs
    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)));
    }
}

Output:

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

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

Homeless

Answer 28

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 https://mcmap.net/q/45459/-how-can-i-initialise-a-static-map)
 */
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> mapOf(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.

EDIT2: Even more recently, I no longer like static method called of, as it looks pretty bad when using static imports. I renamed it to mapOf instead, making it more suitable for static imports.

Calchas

Answer 29

JEP 269 provides some convenience factory methods for Collections API. This factory methods are not in current Java version, which is 8, but are planned for Java 9 release.

For Map there are two factory methods: of and ofEntries. Using of, you can pass alternating key/value pairs. For example, in order to create a Map like {age: 27, major: cs}:

Map<String, Object> info = Map.of("age", 27, "major", "cs");

Currently there are ten overloaded versions for of, so you can create a map containing ten key/value pairs. If you don't like this limitation or alternating key/values, you can use ofEntries:

Map<String, Object> info = Map.ofEntries(
                Map.entry("age", 27),
                Map.entry("major", "cs")
);

Both of and ofEntries will return an immutable Map, so you can't change their elements after construction. You can try out these features using JDK 9 Early Access.

Perspex

Answer 30

Well... I like enums ;)

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

    int value;
    String name;

    MyEnum(int value, String name) {
        this.value = value;
        this.name = name;
    }

    static final Map<Integer, String> MAP = Stream.of( values() )
            .collect( Collectors.toMap( e -> e.value, e -> e.name ) );
}

Corneous

Answer 31

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
        this(DEFAULT_PROPS);
    }

    /**
     * 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) {
        super(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...
    }
}

Hashimoto

Answer 32

Note: This answer actually belongs to question How to directly initialize a HashMap (in a literal way)? but since that was marked as duplicate of this one at time of this writing...

---

Prior to Java 9 with its Map.of() (which is also limited to 10 mappings) you can extend a Map implementation of your choice, e.g.:

public class InitHashMap<K, V> extends HashMap<K, V>

re-implement HashMap's constructors:

public InitHashMap() {
    super();
}

public InitHashMap( int initialCapacity, float loadFactor ) {
    super( initialCapacity, loadFactor );
}

public InitHashMap( int initialCapacity ) {
    super( initialCapacity );
}

public InitHashMap( Map<? extends K, ? extends V> map ) {
    super( map );
}

and add an additional constructor that's inspired by Aerthel's answer but is generic by using Object... and <K, V> types:

public InitHashMap( final Object... keyValuePairs ) {

    if ( keyValuePairs.length % 2 != 0 )
        throw new IllegalArgumentException( "Uneven number of arguments." );

    K key = null;
    int i = -1;

    for ( final Object keyOrValue : keyValuePairs )
        switch ( ++i % 2 ) {
            case 0:  // key
                if ( keyOrValue == null )
                    throw new IllegalArgumentException( "Key[" + (i >>> 1) + "] is <null>." );
                key = (K) keyOrValue;
                continue;
            case 1:  // value
                put( key, (V) keyOrValue );
        }
}

Run

public static void main( final String[] args ) {

    final Map<Integer, String> map = new InitHashMap<>( 1, "First", 2, "Second", 3, "Third" );
    System.out.println( map );
}

Output

{1=First, 2=Second, 3=Third}

---

You also can extend the Map interface likewise:

public interface InitMap<K, V> extends Map<K, V> {

    static <K, V> Map<K, V> of( final Object... keyValuePairs ) {

        if ( keyValuePairs.length % 2 != 0 )
            throw new IllegalArgumentException( "Uneven number of arguments." );

        final Map<K, V> map = new HashMap<>( keyValuePairs.length >>> 1, .75f );
        K key = null;
        int i = -1;

        for ( final Object keyOrValue : keyValuePairs )
            switch ( ++i % 2 ) {
                case 0: // key
                    if ( keyOrValue == null )
                        throw new IllegalArgumentException( "Key[" + (i >>> 1) + "] is <null>." );
                    key = (K) keyOrValue;
                    continue;
                case 1: // value
                    map.put( key, (V) keyOrValue );
            }
        return map;
    }
}

Run

public static void main( final String[] args ) {

    System.out.println( InitMap.of( 1, "First", 2, "Second", 3, "Third" ) );
}

Output

{1=First, 2=Second, 3=Third}

Seawright

Any reason why you chose to do >>> 1 instead of % 2, apart from making it intentionally confusing? – Diphase

@Diphase There are even more than one: 1) If the compiler/JIT doesn't optimize % 2 accordingly–which I don't know–shift operations are much more performant than math operations since they are implemented hard-wired in any CPU I'm aware of. 2) There are only rare cases where shift operations can be used in high-level languages, so I use them whenever I can to remind myself– and others who read my code–that they exist. 3) It increases the lifetime of the other operators due to reduced wearout [just kidding, of course, but I wanted it to be three :] – Seawright

Sounds like something that the compiler should be caring for, no? Adding shift operations into places where a more simplified operation could be shown just leads to misunderstood code. – Diphase

@Diphase SHOULD is not MUST. Shift operations are way simpler than math ops (from a tech POV behind the scenes where 0, 1 and their positions in a combination thereof matter). I agree, they aren't used in high-level language programs that often. Have you ever coded in ASM or machine code? I have and therefore these operations are very familiar to me and I use them if there's the chance to do so. It's OK for me if you don't like and dont' use them. I can live with both. Are you trying to convince me to jettison my knowledge because others don't have that? – Seawright

Answer 33

This one uses Apache commons-lang which will most likely be on your class path already:

Map<String, String> collect = Stream.of(
        Pair.of("hello", "world"),
        Pair.of("abc", "123"),
        Pair.of("java", "eight")
).collect(Collectors.toMap(Pair::getKey, Pair::getValue));

Factional

Answer 34

Java 8 with streams:

    private static final Map<String, TemplateOpts> templates = new HashMap<>();

    static {
        Arrays.stream(new String[][]{
                {CUSTOMER_CSV, "Plantilla cliente", "csv"}
        }).forEach(f -> templates.put(f[0], new TemplateOpts(f[1], f[2])));
    }

It can be also a Object[][] to put anything inside and map it in the forEach loop

---

---

---

Separation of concerns implementation - with method abstraction & generics to decouple things:

    private static final Map<String, TemplateOpts> templates = mapFromArr(
        new String[][]{
                {CUSTOMER_CSV, "Plantilla cliente", "csv"}
        }, arr-> arr[0], arr-> new TemplateOpts(arr[1], arr[2]));

    private static <K,V> Map<K,V> mapFromArr(Object[][] arr, Function<Object[],K> keyFnc, Function<Object[],V> valueFnc) {
        Map<K,V> res = new HashMap<>();
        Arrays.stream(arr).forEach(subArr ->
            res.put(keyFnc.apply(subArr), valueFnc.appy(subArr));
        return res;
    }

Presentday

Answer 35

Now that Java 8 is out, this question warrants revisiting. I took a stab at it -- looks like maybe you can exploit lambda expression syntax to get a pretty nice and concise (but type-safe) map literal syntax that looks like this:

Map<String,Object> myMap = hashMap(
    bob -> 5,
    TheGimp -> 8,
    incredibleKoolAid -> "James Taylor",
    heyArnold -> new Date()
);

Map<String,Integer> typesafeMap = treeMap(
    a -> 5,
    bee -> 8,
    sea -> 13
    deep -> 21
);

Untested sample code at https://gist.github.com/galdosd/10823529 Would be curious about the opinions of others on this (it's mildly evil...)

Bulrush

Note: Turns out, after actually trying it later... the above does not actually work. I tried it with a few different javac flags and was unable to get the name used for the parameter to be retained. – Bulrush

Answer 36

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(
        "1=one",
        "2=two"
).collect(Collectors.toMap(k -> Integer.parseInt(k.split("=")[0]), v -> v.split("=")[1]));

Impress

Answer 37

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

Anzus

Answer 38

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.

Succumb

You could create the map using the double-brace idiom, and then copy it. – Artamas

Answer 39

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;
}

Ahmad

The problem with this approach is that it is not type-safe at all (and if you are using Java, you want type safety). You can put any kind of objects as keys and values. It only really works for a Map<Object, Object> (though one could use an analogous approach with an String[][] for Map<String,String> and similar for other Map<T,T>. It doesn't work for Maps where the key-type is different from the value type. – Protrusile

Answer 40

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<>();
    result.put("foo","hoo");
    ...
    return result;
)).get();

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

Lepto

Answer 41

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;
    }
}

Usage:

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);

Catacaustic

Answer 42

Here is the code by abacus-common

Map<Integer, String> map = N.asMap(1, "one", 2, "two");
// Or for Immutable map 
ImmutableMap<Integer, String> = ImmutableMap.of(1, "one", 2, "two");

Declaration： I'm the developer of abacus-common.

Sacci

Answer 43

Even with Guava's nice ImmutableMap class, sometimes I'd like to build a mutable map fluently. Finding myself wanting to avoid static blocks & the anonymous subtype thing, when Java 8 came along I wrote a tiny library to help called Fluent.

// simple usage, assuming someMap is a Map<String, String> already declared
Map<String, String> example = new Fluent.HashMap<String, String>()
    .append("key1", "val1")
    .append("key2", "val2")
    .appendAll(someMap);

With Java 8 interface defaulting I could implement the Fluent.Map methods for all standard Java Map implementations (ie HashMap, ConcurrentSkipListMap, ... etc) without tedious repetition.

Unmodifiable maps are simple too.

Map<String, Integer> immutable = new Fluent.LinkedHashMap<String, Integer>()
    .append("one", 1)
    .append("two", 2)
    .append("three", 3)
    .unmodifiable();

See https://github.com/alexheretic/fluent for source, documentation and examples.

Onstage