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 lt Integer  String gt  myMap   new HashMap lt  gt         static           myMap put 1   one            myMap put 2   two               private static final Map lt Integer  String gt  myMap2   new HashMap lt  gt                           put 1   one                put 2   two

User · Answer

If you only need to add one value to the map you can use Collections singletonMap    Map lt K  V gt  map   Collections singletonMap key  value

User · Answer

You may use StickyMap and MapEntry from Cactoos   private static final Map lt String  String gt  MAP   new StickyMap lt  gt     new MapEntry lt  gt   name    Jeffrey      new MapEntry lt  gt   age    35

User · Answer

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 lt Integer  String gt  MAP           Maps mutable with 1   one   2   two         private static final MutableMap lt Integer  String gt  MUTABLE MAP          Maps mutable with 1   one   2   two          private static final MutableMap lt Integer  String gt  UNMODIFIABLE MAP           Maps mutable with 1   one   2   two   asUnmodifiable          private static final MutableMap lt Integer  String gt  SYNCHRONIZED MAP           Maps mutable with 1   one   2   two   asSynchronized          private static final ImmutableMap lt Integer  String gt  IMMUTABLE MAP           Maps mutable with 1   one   2   two   toImmutable          private static final ImmutableMap lt Integer  String gt  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 lt String gt  MUTABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two         private static final MutableIntObjectMap lt String gt  UNMODIFIABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        asUnmodifiable         private static final MutableIntObjectMap lt String gt  SYNCHRONIZED INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        asSynchronized         private static final ImmutableIntObjectMap lt String gt  IMMUTABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        toImmutable         private static final ImmutableIntObjectMap lt String gt  IMMUTABLE INT OBJ MAP2               IntObjectMaps immutable  lt String gt empty                        newWithKeyValue 1   one                        newWithKeyValue 2   two         Note  I am a committer for Eclipse Collections

User · Answer

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 lt String  String gt  unmodifiableMap   Map of  key1    value1    key2    value2

User · Answer

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

User · Answer

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  lt K  V gt  Map lt K  V gt  mapOf Map Entry lt K  V gt     entries            LinkedHashMap lt K  V gt  map   new LinkedHashMap lt  gt             for  Map Entry lt K  V gt  entry   entries                map put entry getKey    entry getValue                       return map               Creates a map entry     public static  lt K  V gt  Map Entry lt K  V gt  entry K key  V value            return new AbstractMap SimpleEntry lt  gt  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

User · Answer

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

User · Answer

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 lt Integer  String gt  myMap   prepareMap         private static Map lt Integer  String gt  prepareMap             Map lt Integer  String gt  hashMap   new HashMap lt  gt             hashMap put 1   one            hashMap put 2   two             return hashMap

User · Answer

I would use   public class Test       private static final Map lt Integer  String gt  MY MAP   createMap         private static Map lt Integer  String gt  createMap             Map lt Integer  String gt  result   new HashMap lt  gt             result put 1   one            result put 2   two            return Collections unmodifiableMap result              it avoids an anonymous class  which I personally consider to be a bad style  and avoid it makes the creation of map more explicit it makes map unmodifiable as MY MAP is constant  I would name it like constant

User · Answer

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

User · Answer

Map of in Java 9   private static final Map lt Integer  String gt  MY MAP   Map of 1   one   2   two      See JEP 269 for details  JDK 9 reached general availability in September 2017

User · Answer

As usual apache-commons has proper method MapUtils putAll Map  Object      For example  to create a color map    Map lt String  String gt  colorMap   MapUtils putAll new HashMap lt String  String gt     new String              RED     FF0000           GREEN     00FF00           BLUE     0000FF

User · Answer

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 lt Integer  String gt  CONSTANT MAP        Collections unmodifiableMap new HashMap lt Integer  String gt                put 1   one            put 2   two                  later on      CONSTANT MAP put 3   three       going to throw an exception

User · Answer

I like anonymous class  because it is easy to deal with it   public static final Map lt      gt  numbers   Collections unmodifiableMap new HashMap lt Integer  String gt                    put 1   some value                          rest of code here

User · Answer

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  lt  entries length  x            Object   entry   entries x        map put entry 0   entry 1           return map

User · Answer

Even with Guava s nice ImmutableMap class  sometimes I d like to build a mutable map fluently  Finding myself wanting to avoid static blocks  amp  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 lt String  String gt  already declared Map lt String  String gt  example   new Fluent HashMap lt String  String gt         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 lt String  Integer gt  immutable   new Fluent LinkedHashMap lt String  Integer gt         append  one   1       append  two   2       append  three   3       unmodifiable      See https   github com alexheretic fluent for source  documentation and examples

User · Answer

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 lt Integer  String gt  MY MAP  static       Map lt Integer  String gt tempMap   new HashMap lt Integer  String gt         tempMap put 1   one        tempMap put 2   two        MY MAP   Collections unmodifiableMap tempMap

User · Answer

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

User · Answer

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

User · Answer

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 lt String Object gt  myMap   hashMap      bob - gt  5      TheGimp - gt  8      incredibleKoolAid - gt   James Taylor       heyArnold - gt  new Date       Map lt String Integer gt  typesafeMap   treeMap      a - gt  5      bee - gt  8      sea - gt  13     deep - gt  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

User · Answer

Note  This answer actually belongs to question How to directly initialize a HashMap  in a literal way   but since that s marked as duplicate of this one       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 lt K  V gt  extends HashMap lt K  V gt    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 lt   extends K    extends V gt  map         super  map        and add an additional constructor that s inspired by Aerthel s answer but is generic by using Object    and  lt K  V gt  types   public InitHashMap  final Object    keyValuePairs          if   keyValuePairs length  gt  gt  gt  1    0           throw new IllegalArgumentException   Uneven number of arguments           K key   null      int i   -1       for   final Object keyOrValue   keyValuePairs           switch     i  gt  gt  gt  1                 case 0      key                 if   keyOrValue    null                       throw new IllegalArgumentException   Key      i  gt  gt  gt  1       is  lt null gt                       key    K  keyOrValue                  continue              case 1      value                 put  key   V  keyOrValue                  Run  public static void main  final String   args          final Map lt Integer  String gt  map   new InitHashMap lt  gt   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 lt K  V gt  extends Map lt K  V gt         static  lt K  V gt  Map lt K  V gt  of  final Object    keyValuePairs              if   keyValuePairs length  gt  gt  gt  1    0               throw new IllegalArgumentException   Uneven number of arguments               final Map lt K  V gt  map   new HashMap lt  gt   keyValuePairs length  gt  gt  gt  1   75f            K key   null          int i   -1           for   final Object keyOrValue   keyValuePairs               switch     i  gt  gt  gt  1                     case 0     key                     if   keyOrValue    null                           throw new IllegalArgumentException   Key      i  gt  gt  gt  1       is  lt null gt                           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

User · Answer

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 lt Integer  String gt  myMap   new HashMap lt  gt     static       final Map lt Integer  String gt  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 lt Integer  String gt  myMap2   new HashMap lt  gt     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 lt Integer  String gt  myMap3   new HashMap lt  gt         static           new B lt  gt  myMap3       Instantiating the helper class with our map              p 1   one                p 2   two                p 3   three             class B lt K  V gt        private final Map lt K  V gt  m       public B Map lt K  V gt  m            this m   m             public B lt K  V gt  p K k  V v            m put k  v           return this     Return this for chaining

User · Answer

This one uses Apache commons-lang which will most likely be on your class path already   Map lt String  String gt  collect   Stream of          Pair of  hello    world            Pair of  abc    123            Pair of  java    eight     collect Collectors toMap Pair  getKey  Pair  getValue

User · Answer

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

User · Answer

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  lt A gt  Map lt String  A gt  asMap Object    keysAndValues      return new LinkedHashMap lt String  A gt           for  int i   0  i  lt  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 lt String  String gt  one   asMap  quot 1stKey quot    quot 1stVal quot    quot 2ndKey quot    quot 2ndVal quot    Map lt String  Object gt  two   asMap  quot 1stKey quot   Boolean TRUE   quot 2ndKey quot   new Integer 2

User · Answer

I would use   public class Test       private static final Map lt Integer  String gt  MY MAP   createMap         private static Map lt Integer  String gt  createMap             Map lt Integer  String gt  result   new HashMap lt  gt             result put 1   one            result put 2   two            return Collections unmodifiableMap result              it avoids an anonymous class  which I personally consider to be a bad style  and avoid it makes the creation of map more explicit it makes map unmodifiable as MY MAP is constant  I would name it like constant

User · Answer

Map of in Java 9   private static final Map lt Integer  String gt  MY MAP   Map of 1   one   2   two      See JEP 269 for details  JDK 9 reached general availability in September 2017

User · Answer

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 lt Integer  String gt  MY MAP  static       Map lt Integer  String gt tempMap   new HashMap lt Integer  String gt         tempMap put 1   one        tempMap put 2   two        MY MAP   Collections unmodifiableMap tempMap

User · Answer

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 lt Integer  String gt  myMap   prepareMap         private static Map lt Integer  String gt  prepareMap             Map lt Integer  String gt  hashMap   new HashMap lt  gt             hashMap put 1   one            hashMap put 2   two             return hashMap

User · Answer

public class Test       private static final Map lt Integer  String gt  myMap      static           Map lt Integer  String gt  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

User · Answer

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  lt A gt  Map lt String  A gt  asMap Object    keysAndValues      return new LinkedHashMap lt String  A gt           for  int i   0  i  lt  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 lt String  String gt  one   asMap  quot 1stKey quot    quot 1stVal quot    quot 2ndKey quot    quot 2ndVal quot    Map lt String  Object gt  two   asMap  quot 1stKey quot   Boolean TRUE   quot 2ndKey quot   new Integer 2

User · Answer

I like anonymous class  because it is easy to deal with it   public static final Map lt      gt  numbers   Collections unmodifiableMap new HashMap lt Integer  String gt                    put 1   some value                          rest of code here

User · Answer

This one uses Apache commons-lang which will most likely be on your class path already   Map lt String  String gt  collect   Stream of          Pair of  hello    world            Pair of  abc    123            Pair of  java    eight     collect Collectors toMap Pair  getKey  Pair  getValue

User · Answer

If you want something terse and relatively safe  you can just shift compile-time type checking to run-time   static final Map lt String  Integer gt  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  lt K  V gt  HashMap lt K  V gt  unmodifiableMap              Class lt   extends K gt  keyClazz              Class lt   extends V gt  valClazz              Object   keyValues                return Collections  lt K  V gt unmodifiableMap makeMap              keyClazz              valClazz              keyValues               public static  lt K  V gt  HashMap lt K  V gt  makeMap              Class lt   extends K gt  keyClazz              Class lt   extends V gt  valClazz              Object   keyValues                if  keyValues length   2    0                        throw new IllegalArgumentException                        keyValues  was formatted incorrectly                           Expected an even length  but found      keyValues length                             HashMap lt K  V gt  result   new HashMap lt K  V gt  keyValues length   2            for  int i   0  i  lt  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  lt T gt  T cast Class lt   extends T gt  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

User · Answer

If you can use a String representation of your data this is an option too in Java 8   static Map lt Integer  String gt  MAP   Stream of           1 one            2 two    collect Collectors toMap k - gt  Integer parseInt k split      0    v - gt  v split      1

User · Answer

Here s a Java 8 one-line static map initializer   private static final Map lt String  String gt  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 - gt  kv 0   kv - gt  kv 1       Edit  to initialize a Map lt Integer  String gt  as in the question  you d need something like this   static final Map lt Integer  String gt  MY MAP   Arrays stream new Object               1   one             2   two       collect Collectors toMap kv - gt   Integer  kv 0   kv - gt   String  kv 1       Edit 2   There is a better  mixed-type-capable version by i am zero that uses a stream of new SimpleEntry lt  gt  k  v  calls  Check out that answer  https   stackoverflow com a 37384773 3950982

User · Answer

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 lt Integer  String gt  myMap      static           Map lt Integer  String gt  aMap                 aMap put 1   one            aMap put 2   two            myMap   Collections unmodifiableMap aMap

User · Answer

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

User · Answer

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 lt Integer String gt  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  Neat Solution   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 lt Integer  String gt  myMap   Stream of              new SimpleEntry lt  gt  1   one                new SimpleEntry lt  gt  2   two                new SimpleEntry lt  gt  3   three                new SimpleEntry lt  gt  4   four                new SimpleEntry lt  gt  5   five                new SimpleEntry lt  gt  6   six                new SimpleEntry lt  gt  7   seven                new SimpleEntry lt  gt  8   eight                new SimpleEntry lt  gt  9   nine                new SimpleEntry lt  gt  10   ten                 collect Collectors toMap SimpleEntry  getKey  SimpleEntry  getValue

User · Answer

I would use   public class Test       private static final Map lt Integer  String gt  MY MAP   createMap         private static Map lt Integer  String gt  createMap             Map lt Integer  String gt  result   new HashMap lt  gt             result put 1   one            result put 2   two            return Collections unmodifiableMap result              it avoids an anonymous class  which I personally consider to be a bad style  and avoid it makes the creation of map more explicit it makes map unmodifiable as MY MAP is constant  I would name it like constant

User · Answer

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    The elements are nested and inline  It is more OO  not procedural  the performance impact is really small and could be ignored  Better IDE outline support  rather then many anonymous static   block  You saved few lines of comment to bring them relationship  Prevent possible element leak instance lead of uninitialized object from exception and bytecode optimizer  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

User · Answer

Note  This answer actually belongs to question How to directly initialize a HashMap  in a literal way   but since that s marked as duplicate of this one       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 lt K  V gt  extends HashMap lt K  V gt    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 lt   extends K    extends V gt  map         super  map        and add an additional constructor that s inspired by Aerthel s answer but is generic by using Object    and  lt K  V gt  types   public InitHashMap  final Object    keyValuePairs          if   keyValuePairs length  gt  gt  gt  1    0           throw new IllegalArgumentException   Uneven number of arguments           K key   null      int i   -1       for   final Object keyOrValue   keyValuePairs           switch     i  gt  gt  gt  1                 case 0      key                 if   keyOrValue    null                       throw new IllegalArgumentException   Key      i  gt  gt  gt  1       is  lt null gt                       key    K  keyOrValue                  continue              case 1      value                 put  key   V  keyOrValue                  Run  public static void main  final String   args          final Map lt Integer  String gt  map   new InitHashMap lt  gt   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 lt K  V gt  extends Map lt K  V gt         static  lt K  V gt  Map lt K  V gt  of  final Object    keyValuePairs              if   keyValuePairs length  gt  gt  gt  1    0               throw new IllegalArgumentException   Uneven number of arguments               final Map lt K  V gt  map   new HashMap lt  gt   keyValuePairs length  gt  gt  gt  1   75f            K key   null          int i   -1           for   final Object keyOrValue   keyValuePairs               switch     i  gt  gt  gt  1                     case 0     key                     if   keyOrValue    null                           throw new IllegalArgumentException   Key      i  gt  gt  gt  1       is  lt null gt                           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

User · Answer

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 lt Integer  String gt  CONSTANT MAP        Collections unmodifiableMap new HashMap lt Integer  String gt                put 1   one            put 2   two                  later on      CONSTANT MAP put 3   three       going to throw an exception

User · Answer

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 lt Integer String gt  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  Neat Solution   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 lt Integer  String gt  myMap   Stream of              new SimpleEntry lt  gt  1   one                new SimpleEntry lt  gt  2   two                new SimpleEntry lt  gt  3   three                new SimpleEntry lt  gt  4   four                new SimpleEntry lt  gt  5   five                new SimpleEntry lt  gt  6   six                new SimpleEntry lt  gt  7   seven                new SimpleEntry lt  gt  8   eight                new SimpleEntry lt  gt  9   nine                new SimpleEntry lt  gt  10   ten                 collect Collectors toMap SimpleEntry  getKey  SimpleEntry  getValue

User · Answer

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 lt String  Object gt  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 lt String  Object gt  DEFAULT PROPS   new HashMap lt  gt          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 lt String  Object gt  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

User · Answer

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 lt String  Object gt  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 lt String  Object gt  DEFAULT PROPS   new HashMap lt  gt          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 lt String  Object gt  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

User · Answer

Java 8 with streams      private static final Map lt String  TemplateOpts gt  templates   new HashMap lt  gt          static           Arrays stream new String                       CUSTOMER CSV   quot Plantilla cliente quot    quot csv quot              forEach f - gt  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

User · Answer

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 lt Integer  String gt  myMap      static           Map lt Integer  String gt  aMap                 aMap put 1   one            aMap put 2   two            myMap   Collections unmodifiableMap aMap

User · Answer

With Java 8 I ve come to use the following pattern   private static final Map lt String  Integer gt  MAP   Stream of      new AbstractMap SimpleImmutableEntry lt  gt   key1   1       new AbstractMap SimpleImmutableEntry lt  gt   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

User · Answer

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

User · Answer

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  lt K  V gt  Map lt K  V gt  mapOf Object    keyValues        Map lt K  V gt  map   new HashMap lt  gt  keyValues length   2        for  int index   0  index  lt  keyValues length   2  index              map put  K keyValues index   2    V keyValues index   2   1               return map     Map lt Integer  String gt  map1   mapOf 1   value1   2   value2    Map lt String  String gt  map2   mapOf  key1    value1    key2    value2      Note  in Java 9 you can use Map of

User · Answer

As usual apache-commons has proper method MapUtils putAll Map  Object      For example  to create a color map    Map lt String  String gt  colorMap   MapUtils putAll new HashMap lt String  String gt     new String              RED     FF0000           GREEN     00FF00           BLUE     0000FF

User · Answer

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 lt Integer  String gt  myMap      static           Map lt Integer  String gt  aMap                 aMap put 1   one            aMap put 2   two            myMap   Collections unmodifiableMap aMap

User · Answer

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 lt Integer  String gt  myMap      static           Map lt Integer  String gt  aMap                 aMap put 1   one            aMap put 2   two            myMap   Collections unmodifiableMap aMap

User · Answer

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 lt Integer  String gt  MAP           Maps mutable with 1   one   2   two         private static final MutableMap lt Integer  String gt  MUTABLE MAP          Maps mutable with 1   one   2   two          private static final MutableMap lt Integer  String gt  UNMODIFIABLE MAP           Maps mutable with 1   one   2   two   asUnmodifiable          private static final MutableMap lt Integer  String gt  SYNCHRONIZED MAP           Maps mutable with 1   one   2   two   asSynchronized          private static final ImmutableMap lt Integer  String gt  IMMUTABLE MAP           Maps mutable with 1   one   2   two   toImmutable          private static final ImmutableMap lt Integer  String gt  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 lt String gt  MUTABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two         private static final MutableIntObjectMap lt String gt  UNMODIFIABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        asUnmodifiable         private static final MutableIntObjectMap lt String gt  SYNCHRONIZED INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        asSynchronized         private static final ImmutableIntObjectMap lt String gt  IMMUTABLE INT OBJ MAP               IntObjectMaps mutable  lt String gt empty                        withKeyValue 1   one                        withKeyValue 2   two                        toImmutable         private static final ImmutableIntObjectMap lt String gt  IMMUTABLE INT OBJ MAP2               IntObjectMaps immutable  lt String gt empty                        newWithKeyValue 1   one                        newWithKeyValue 2   two         Note  I am a committer for Eclipse Collections

User · Answer

In Java 8  procedural approach can also be wrapped in Supplier   Map lt String String gt  m     Supplier lt Map lt String String gt  gt      - gt        Map lt String String gt  result   new HashMap lt  gt         result put  foo   hoo                return result     get      It s only hypothetical way but can come handy if you really need one-liner

User · Answer

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  lt K  V gt  Map lt K  V gt  mapOf Map Entry lt K  V gt     entries            LinkedHashMap lt K  V gt  map   new LinkedHashMap lt  gt             for  Map Entry lt K  V gt  entry   entries                map put entry getKey    entry getValue                       return map               Creates a map entry     public static  lt K  V gt  Map Entry lt K  V gt  entry K key  V value            return new AbstractMap SimpleEntry lt  gt  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

User · Answer

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  lt K  V gt  Map lt K  V gt  mapOf Object    keyValues        Map lt K  V gt  map   new HashMap lt  gt  keyValues length   2        for  int index   0  index  lt  keyValues length   2  index              map put  K keyValues index   2    V keyValues index   2   1               return map     Map lt Integer  String gt  map1   mapOf 1   value1   2   value2    Map lt String  String gt  map2   mapOf  key1    value1    key2    value2      Note  in Java 9 you can use Map of

User · Answer

If you only need to add one value to the map you can use Collections singletonMap    Map lt K  V gt  map   Collections singletonMap key  value

User · Answer

Here is the code by AbacusUtil  Map lt Integer  String gt  map   N asMap 1   one   2   two       Or for Immutable map  ImmutableMap lt Integer  String gt    ImmutableMap of 1   one   2   two      Declaration  I m the developer of AbacusUtil

User · Answer

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 lt Integer  String gt  CONSTANT MAP        Collections unmodifiableMap new HashMap lt Integer  String gt                put 1   one            put 2   two                  later on      CONSTANT MAP put 3   three       going to throw an exception

User · Answer

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 lt String  Object gt  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 lt String  Object gt  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

User · Answer

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

User · Answer

Here is the code by AbacusUtil  Map lt Integer  String gt  map   N asMap 1   one   2   two       Or for Immutable map  ImmutableMap lt Integer  String gt    ImmutableMap of 1   one   2   two      Declaration  I m the developer of AbacusUtil

User · Answer

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 lt Integer  String gt  myMap   new HashMap lt  gt     static       final Map lt Integer  String gt  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 lt Integer  String gt  myMap2   new HashMap lt  gt     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 lt Integer  String gt  myMap3   new HashMap lt  gt         static           new B lt  gt  myMap3       Instantiating the helper class with our map              p 1   one                p 2   two                p 3   three             class B lt K  V gt        private final Map lt K  V gt  m       public B Map lt K  V gt  m            this m   m             public B lt K  V gt  p K k  V v            m put k  v           return this     Return this for chaining

User · Answer

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  lt  entries length  x            Object   entry   entries x        map put entry 0   entry 1           return map

User · Answer

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  lt br  gt       code MapBuilder of  name    Forrest   and  surname    Gump   build        param  lt K gt  key type  inferred by constructor      param  lt V gt  value type  inferred by constructor      author Vlasec  for http   stackoverflow com a 30345279 1977151      public class MapBuilder  lt K  V gt        private Map lt K  V gt  map   new HashMap lt  gt              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  lt A  B gt  MapBuilder lt A  B gt  mapOf A key  B value            return new MapBuilder lt  gt  key  value                  Puts the key-value pair to the map and returns itself for method chaining        public MapBuilder lt K  V gt  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 lt K  V gt  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

User · Answer

Even with Guava s nice ImmutableMap class  sometimes I d like to build a mutable map fluently  Finding myself wanting to avoid static blocks  amp  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 lt String  String gt  already declared Map lt String  String gt  example   new Fluent HashMap lt String  String gt         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 lt String  Integer gt  immutable   new Fluent LinkedHashMap lt String  Integer gt         append  one   1       append  two   2       append  three   3       unmodifiable      See https   github com alexheretic fluent for source  documentation and examples

User · Answer

I would use   public class Test       private static final Map lt Integer  String gt  MY MAP   createMap         private static Map lt Integer  String gt  createMap             Map lt Integer  String gt  result   new HashMap lt  gt             result put 1   one            result put 2   two            return Collections unmodifiableMap result              it avoids an anonymous class  which I personally consider to be a bad style  and avoid it makes the creation of map more explicit it makes map unmodifiable as MY MAP is constant  I would name it like constant

User · Answer

If you want something terse and relatively safe  you can just shift compile-time type checking to run-time   static final Map lt String  Integer gt  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  lt K  V gt  HashMap lt K  V gt  unmodifiableMap              Class lt   extends K gt  keyClazz              Class lt   extends V gt  valClazz              Object   keyValues                return Collections  lt K  V gt unmodifiableMap makeMap              keyClazz              valClazz              keyValues               public static  lt K  V gt  HashMap lt K  V gt  makeMap              Class lt   extends K gt  keyClazz              Class lt   extends V gt  valClazz              Object   keyValues                if  keyValues length   2    0                        throw new IllegalArgumentException                        keyValues  was formatted incorrectly                           Expected an even length  but found      keyValues length                             HashMap lt K  V gt  result   new HashMap lt K  V gt  keyValues length   2            for  int i   0  i  lt  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  lt T gt  T cast Class lt   extends T gt  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

User · Answer

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  lt K V gt  Map lt K V gt  map Map Entry lt K    extends V gt     entries   public static  lt K V gt  Map Entry lt K V gt  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

User · Answer

Java 8 with streams      private static final Map lt String  TemplateOpts gt  templates   new HashMap lt  gt          static           Arrays stream new String                       CUSTOMER CSV   quot Plantilla cliente quot    quot csv quot              forEach f - gt  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

User · Answer

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 lt String  Object gt  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 lt String  Object gt  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

User · Answer

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  lt  entries length  x            Object   entry   entries x        map put entry 0   entry 1           return map

User · Answer

In Java 8  procedural approach can also be wrapped in Supplier   Map lt String String gt  m     Supplier lt Map lt String String gt  gt      - gt        Map lt String String gt  result   new HashMap lt  gt         result put  foo   hoo                return result     get      It s only hypothetical way but can come handy if you really need one-liner

User · Answer

If you can use a String representation of your data this is an option too in Java 8   static Map lt Integer  String gt  MAP   Stream of           1 one            2 two    collect Collectors toMap k - gt  Integer parseInt k split      0    v - gt  v split      1

User · Answer

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 lt Integer  String gt  MAP   Stream of  values                  collect  Collectors toMap  e - gt  e value  e - gt  e name

User · Answer

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

User · Answer

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

User · Answer

Java 5 provides this more compact syntax   static final Map lt String   String gt  FLAVORS   new HashMap lt String   String gt           put  Up       Down        put  Charm    Strange        put  Top      Bottom

User · Answer

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

User · Answer

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 lt Integer  String gt  CONSTANT MAP        Collections unmodifiableMap new HashMap lt Integer  String gt                put 1   one            put 2   two                  later on      CONSTANT MAP put 3   three       going to throw an exception

User · Answer

I like the Guava way of initialising a static  immutable map   static final Map lt Integer  String gt  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 lt Integer  String gt  MY MAP   ImmutableMap  lt Integer  String gt 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 lt Integer  String gt  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 lt Integer  String gt  MY MAP   Map of      1   one        2   two

User · Answer

I like the Guava way of initialising a static  immutable map   static final Map lt Integer  String gt  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 lt Integer  String gt  MY MAP   ImmutableMap  lt Integer  String gt 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 lt Integer  String gt  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 lt Integer  String gt  MY MAP   Map of      1   one        2   two

User · Answer

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  lt br  gt       code MapBuilder of  name    Forrest   and  surname    Gump   build        param  lt K gt  key type  inferred by constructor      param  lt V gt  value type  inferred by constructor      author Vlasec  for http   stackoverflow com a 30345279 1977151      public class MapBuilder  lt K  V gt        private Map lt K  V gt  map   new HashMap lt  gt              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  lt A  B gt  MapBuilder lt A  B gt  mapOf A key  B value            return new MapBuilder lt  gt  key  value                  Puts the key-value pair to the map and returns itself for method chaining        public MapBuilder lt K  V gt  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 lt K  V gt  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

User · Answer

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

User · Answer

You may use StickyMap and MapEntry from Cactoos   private static final Map lt String  String gt  MAP   new StickyMap lt  gt     new MapEntry lt  gt   name    Jeffrey      new MapEntry lt  gt   age    35

User · Answer

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 lt 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 lt String Double gt  aMap    Map lt String Double gt  newMap  key1   1 23   key2   2 34

User · Answer

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 lt Integer  String gt  MY MAP  static       Map lt Integer  String gt tempMap   new HashMap lt Integer  String gt         tempMap put 1   one        tempMap put 2   two        MY MAP   Collections unmodifiableMap tempMap

User · Answer

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  lt  entries length  x            Object   entry   entries x        map put entry 0   entry 1           return map

User · Answer

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 lt 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 lt String Double gt  aMap    Map lt String Double gt  newMap  key1   1 23   key2   2 34

User · Answer

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 lt Integer  String gt  MY MAP  static       Map lt Integer  String gt tempMap   new HashMap lt Integer  String gt         tempMap put 1   one        tempMap put 2   two        MY MAP   Collections unmodifiableMap tempMap

User · Answer

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

User · Answer

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

User · Answer

With Java 8 I ve come to use the following pattern   private static final Map lt String  Integer gt  MAP   Stream of      new AbstractMap SimpleImmutableEntry lt  gt   key1   1       new AbstractMap SimpleImmutableEntry lt  gt   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

User · Answer

Java 5 provides this more compact syntax   static final Map lt String   String gt  FLAVORS   new HashMap lt String   String gt           put  Up       Down        put  Charm    Strange        put  Top      Bottom

User · Answer

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    The elements are nested and inline  It is more OO  not procedural  the performance impact is really small and could be ignored  Better IDE outline support  rather then many anonymous static   block  You saved few lines of comment to bring them relationship  Prevent possible element leak instance lead of uninitialized object from exception and bytecode optimizer  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

User · Answer

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

User · Answer

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 lt Integer  String gt  MAP   Stream of  values                  collect  Collectors toMap  e - gt  e value  e - gt  e name

User · Answer

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  lt K V gt  Map lt K V gt  map Map Entry lt K    extends V gt     entries   public static  lt K V gt  Map Entry lt K V gt  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

User · Answer

public class Test       private static final Map lt Integer  String gt  myMap      static           Map lt Integer  String gt  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

User · Answer

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 lt String Object gt  myMap   hashMap      bob - gt  5      TheGimp - gt  8      incredibleKoolAid - gt   James Taylor       heyArnold - gt  new Date       Map lt String Integer gt  typesafeMap   treeMap      a - gt  5      bee - gt  8      sea - gt  13     deep - gt  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

User · Answer

Here s a Java 8 one-line static map initializer   private static final Map lt String  String gt  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 - gt  kv 0   kv - gt  kv 1       Edit  to initialize a Map lt Integer  String gt  as in the question  you d need something like this   static final Map lt Integer  String gt  MY MAP   Arrays stream new Object               1   one             2   two       collect Collectors toMap kv - gt   Integer  kv 0   kv - gt   String  kv 1       Edit 2   There is a better  mixed-type-capable version by i am zero that uses a stream of new SimpleEntry lt  gt  k  v  calls  Check out that answer  https   stackoverflow com a 37384773 3950982

User · Answer

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 lt String  String gt  unmodifiableMap   Map of  key1    value1    key2    value2

[java] How can I initialise a static Map?

Examples related to java

Examples related to dictionary

Examples related to collections

Examples related to initialization

Examples related to idioms