How to directly initialize a HashMap in a literal way

Question

Is there some way of initializing a Java HashMap like this    Map lt String String gt  test        new HashMap lt String  String gt   test   test   test   test      What would be the correct syntax  I have not found anything regarding this  Is this possible  I am looking for the shortest fastest way to put some  final static  values in a map that never change and are known in advance when creating the Map

User · Answer

tl dr  Use Map of    methods in Java 9 and later   Map lt  String   String  gt  animalSounds       Map of           dog      bark         key   value          cat      meow         key   value          bird     chirp        key   value           Map of  Java 9 added a series of Map of static methods to do just what you want  Instantiate an immutable Map using literal syntax   The map  a collection of entries  is immutable  so you cannot add or remove entries after instantiating  Also  the key and the value of each entry is immutable  cannot be changed  See the Javadoc for other rules  such as no NULLs allowed  no duplicate keys allowed  and the iteration order of mappings is arbitrary   Let s look at these methods  using some sample data for a map of day-of-week to a person who we expect will work on that day   Person alice   new Person   Alice     Person bob   new Person   Bob     Person carol   new Person   Carol       Map of    Map of creates an empty Map  Unmodifiable  so you cannot add entries  Here is an example of such a map  empty with no entries   Map  lt  DayOfWeek  Person  gt  dailyWorkerEmpty   Map of         dailyWorkerEmpty toString         Map of         Map of  k   v   k   v        are several methods that take 1 to 10 key-value pairs  Here is an example of two entries   Map  lt  DayOfWeek  Person  gt  weekendWorker            Map of               DayOfWeek SATURDAY   alice          key   value             DayOfWeek SUNDAY   bob              key   value                  weekendWorker toString     SUNDAY Person  name  Bob     SATURDAY Person  name  Alice       Map ofEntries         Map ofEntries  Map Entry         takes any number of objects implementing the Map Entry interface  Java bundles two classes implementing that interface  one mutable  the other immutable      AbstractMap SimpleEntry  AbstractMap SimpleImmutableEntry  But we need not specify a concrete class  We merely need to call Map entry  k   v   method  pass our key and our value  and we get back an object of a some class implementing Map Entry interface   Map  lt  DayOfWeek  Person  gt  weekdayWorker   Map ofEntries          Map entry  DayOfWeek MONDAY   alice                   Call to  Map entry  method returns an object implementing  Map Entry            Map entry  DayOfWeek TUESDAY   bob             Map entry  DayOfWeek WEDNESDAY   bob             Map entry  DayOfWeek THURSDAY   carol             Map entry  DayOfWeek FRIDAY   carol           weekdayWorker toString     WEDNESDAY Person  name  Bob     TUESDAY Person  name  Bob     THURSDAY Person  name  Carol     FRIDAY Person  name  Carol     MONDAY Person  name  Alice       Map copyOf  Java 10 added the method Map copyOf  Pass an existing map  get back an immutable copy of that map    Notes  Notice that the iterator order of maps produced via Map of are not guaranteed  The entries have an arbitrary order  Do not write code based on the order seen  as the documentation warns the order is subject to change   Note that all of these Map of    methods return a Map of an unspecified class  The underlying concrete class may even vary from one version of Java to another  This anonymity enables Java to choose from various implementations  whatever optimally fits your particular data  For example  if your keys come from an enum  Java might use an EnumMap under the covers

User · Answer

There is no direct way to do this - Java has no Map literals  yet - I think they were proposed for Java 8    Some people like this   Map lt String String gt  test   new HashMap lt String  String gt             put  test   test    put  test   test         This creates an anonymous subclass of HashMap  whose instance initializer puts these values   By the way  a map can t contain twice the same value  your second put will overwrite the first one  I ll use different values for the next examples    The normal way would be this  for a local variable    Map lt String String gt  test   new HashMap lt String  String gt     test put  test   test    test put  test1   test2      If your test map is an instance variable  put the initialization in a constructor or instance initializer   Map lt String String gt  test   new HashMap lt String  String gt           test put  test   test        test put  test1   test2        If your test map is a class variable  put the initialization in a static initializer   static Map lt String String gt  test   new HashMap lt String  String gt     static       test put  test   test        test put  test1   test2        If you want your map to never change  you should after the initialization wrap your map by Collections unmodifiableMap       You can do this in a static initializer too   static Map lt String String gt  test        Map lt String String gt  temp   new HashMap lt String  String gt         temp put  test   test        temp put  test1   test2        test   Collections unmodifiableMap temp        I m not sure if you can now make test final     try it out and report here

User · Answer

This is one way  Map lt String  String gt  h   new HashMap lt String  String gt           put  quot a quot   quot b quot         However  you should be careful and make sure that you understand the above code  it creates a new class that inherits from HashMap   Therefore  you should read more here  http   www c2 com cgi wiki DoubleBraceInitialization   or simply use Guava  Map lt String  Integer gt  left   ImmutableMap of  quot a quot   1   quot b quot   2   quot c quot   3    ImmutableMap of works for up to 5 entries  Otherwise  use the builder  source

User · Answer

If you allow 3rd party libs  you can use Guava s ImmutableMap to achieve literal-like brevity   Map lt String  String gt  test   ImmutableMap of  k1    v1    k2    v2      This works for up to 5 key value pairs  otherwise you can use its builder   Map lt String  String gt  test   ImmutableMap  lt String  String gt builder        put  k1    v1        put  k2    v2                build         note that Guava s ImmutableMap implementation differs from Java s HashMap implementation  most notably it is immutable and does not permit null keys values  for more info  see Guava s user guide article on its immutable collection types

User · Answer

We can initialize hashmap using following ways    HashMap using Constructor Map lt String  String gt  hashMap   new HashMap lt String  String gt      hashMap put  quot hcl quot    quot amit quot      hashMap put  quot tcs quot   quot ravi quot       Hashmap have four different type constructor so we can initialize it as per our requirement  Now using HashMap int initialCapacity  constructor     Map lt String  String gt  hashMap   new HashMap lt String  String gt  3       hashMap put  quot virat quot    quot cricket quot        hashMap put  quot amit quot   quot football quot     Reference   How to create HashMap  Singleton HashMaps using Collections   Map lt String  String gt  immutableMap   Collections singletonMap  quot rohit quot            quot cricket quot      Empty HashMaps using Collections   Map lt String  String gt  emptyMap   Collections emptyMap      Anonymous Subclass to Create HashMap    Map lt String  String gt  map   new HashMap lt String  String gt            put  quot hcl quot    quot amit quot         put  quot tcs quot   quot ravi quot         put  quot wipro quot   quot anmol quot

User · Answer

JAVA 8  In plain java 8 you also have the possibility of using Streams Collectors to do the job   Map lt String  String gt  myMap   Stream of           new SimpleEntry lt  gt   key1    value1             new SimpleEntry lt  gt   key2    value2             new SimpleEntry lt  gt   key3    value3             collect toMap SimpleEntry  getKey  SimpleEntry  getValue      This has the advantage of not creating an Anonymous class   Note that the imports are   import static java util stream Collectors toMap  import java util AbstractMap SimpleEntry    Of course  as noted in other answers  in java 9 onwards you have simpler ways of doing the same

User · Answer

Unfortunately  using varargs if the type of the keys and values are not the same is not very reasonable as you d have to use Object    and lose type safety completely  If you always want to create e g  a Map lt String  String gt   of course a toMap String    args  would be possible though  but not very pretty as it would be easy to mix up keys and values  and an odd number of arguments would be invalid   You could create a sub-class of HashMap that has a chainable method like  public class ChainableMap lt K  V gt  extends HashMap lt K  V gt      public ChainableMap lt K  V gt  set K k  V v        put k  v       return this          and use it like new ChainableMap lt String  Object gt    set  a   1  set  b    foo    Another approach is to use the common builder pattern   public class MapBuilder lt K  V gt      private Map lt K  V gt  mMap   new HashMap lt  gt        public MapBuilder lt K  V gt  put K k  V v        mMap put k  v       return this         public Map lt K  V gt  build         return mMap          and use it like new MapBuilder lt String  Object gt    put  a   1  put  b    foo   build     However  the solution I ve used now and then utilizes varargs and the Pair class   public class Maps     public static  lt K  V gt  Map lt K  V gt  of Pair lt K  V gt     pairs        Map lt K  V gt    new HashMap lt  gt          for  Pair lt K  V gt  pair   pairs          map put pair first  pair second              return map          Map lt String  Object gt  map   Maps of Pair create  a   1   Pair create  b    foo     The verbosity of Pair create   bothers me a bit  but this works quite fine  If you don t mind static imports you could of course create a helper   public  lt K  V gt  Pair lt K  V gt  p K k  V v      return Pair create k  v       Map lt String  Object gt  map   Maps of p  a   1   p  b    foo      Instead of Pair one could imagine using Map Entry  but since it s an interface it requires an implementing class and or a helper factory method  It s also not immutable  and contains other logic not useful for this task

User · Answer

All Versions  In case you happen to need just a single entry  There is Collections singletonMap  key    value     For Java Version 9 or higher   Yes  this is possible now  In Java 9 a couple of factory methods have been added that simplify the creation of maps       this works for up to 10 elements  Map lt String  String gt  test1   Map of       a    b        c    d         this works for any number of elements  import static java util Map entry      Map lt String  String gt  test2   Map ofEntries      entry  a    b        entry  c    d        In the example above both test and test2 will be the same  just with different ways of expressing the Map  The Map of method is defined for up to ten elements in the map  while the Map ofEntries method will have no such limit   Note that in this case the resulting map will be an immutable map  If you want the map to be mutable  you could copy it again  e g  using mutableMap   new HashMap lt  gt  Map of  a    b       See also JEP 269 and the Javadoc   For up to Java Version 8   No  you will have to add all the elements manually  You can use an initializer in an anonymous subclass to make the syntax a little bit shorter   Map lt String  String gt  myMap   new HashMap lt String  String gt               put  a    b            put  c    d              However  the anonymous subclass might introduce unwanted behavior in some cases  This includes for example    It generates an additional class which increases memory consumption  disk space consumption and startup-time In case of a non-static method  It holds a reference to the object the creating method was called upon  That means the object of the outer class cannot be garbage collected while the created map object is still referenced  thus blocking additional memory   Using a function for initialization will also enable you to generate a map in an initializer  but avoids nasty side-effects   Map lt String  String gt  myMap   createMap     private static Map lt String  String gt  createMap         Map lt String String gt  myMap   new HashMap lt String String gt         myMap put  a    b        myMap put  c    d        return myMap

User · Answer

We can use AbstractMap Class having SimpleEntry which allows the creation of immutable map Map lt String  String gt  map5   Stream of      new AbstractMap SimpleEntry lt  gt   quot Sakshi quot   quot java quot        new AbstractMap SimpleEntry lt  gt   quot fine quot   quot python quot         collect Collectors toMap Map Entry  getKey  Map Entry  getValue             System out println map5 get  quot Sakshi quot         map5 put  quot Shiva quot    quot Javascript quot        System out println map5 get  quot Shiva quot       here we can add multiple entries

User · Answer

If you need to place only one key-value pair  you can use Collections singletonMap key  value

User · Answer

Map lt String String gt  test   new HashMap lt String  String gt                    put key1  value1           put key2  value2

User · Answer

You can use Streams In Java 8  this is exmaple of Set     Test public void whenInitializeUnmodifiableSetWithDoubleBrace containsElements         Set lt String gt  countries   Stream of  India    USSR    USA          collect collectingAndThen toSet    Collections  unmodifiableSet         assertTrue countries contains  India         Ref  https   www baeldung com java-double-brace-initialization

User · Answer

Based on  johnny-willer s answer  you cannot get a map with null values on Java 8 because of Collectors toMap relies on Map merge  This method does not expect null values  so it throws a NullPointerException as it was described in this bug report  https   bugs openjdk java net browse JDK-8148463 An alternative way to get a map with null values using a builder syntax on Java 8 is writing an inline collector  Map lt String  String gt  myMap   Stream of           new SimpleEntry lt  gt   quot key1 quot    quot value1 quot             new SimpleEntry lt  gt   quot key2 quot    String  null            new SimpleEntry lt  gt   quot key3 quot    quot value3 quot             collect HashMap  new                   map  entry  - gt  map put entry getKey                                            entry getValue                     HashMap  putAll    Also  this implementation will replace a value if the key appears multiple times  The default Collectors toMap  without a custom merge function like  prev  next  - gt  next  will throw an IllegalStatException instead

User · Answer

You could possibly make your own Map of  which is only available in Java 9 and higher  method easily in 2 easy ways  Make it with a set amount of parameters  Example  public  lt K V gt  Map lt K V gt  mapOf K k1  V v1  K k2  V v2    perhaps more parameters           return new HashMap lt K  V gt             put k1  v1         put k2   v2            etc                Make it using a List  You can also make this using a list  instead of making a lot of methods for a certain set of parameters   Example  public  lt K  V gt  Map lt K  V gt  mapOf List lt K gt  keys  List lt V gt  values       if keys size      values size              throw new IndexOutOfBoundsException  amount of keys and values is not equal               return new HashMap lt K  V gt               IntStream range 0  keys size    forEach index - gt  put keys get index   values get index                 Note It is not recommended to use this for everything as this makes an anonymous class every time you use this

User · Answer

An alternative  using plain Java 7 classes and varargs  create a class HashMapBuilder with this method        public static HashMap lt String  String gt  build String    data       HashMap lt String  String gt  result   new HashMap lt String  String gt          if data length   2    0           throw new IllegalArgumentException  Odd number of arguments               String key   null      Integer step   -1       for String value   data           step            switch step   2           case 0               if value    null                  throw new IllegalArgumentException  Null key value                 key   value              continue          case 1                           result put key  value               break                       return result      Use the method like this   HashMap lt String String gt  data   HashMapBuilder build  key1   value1   key2   value2

User · Answer

You can create a method to initialize the map like in this example below  Map lt String  Integer gt  initializeMap       Map lt String  Integer gt  ret   new HashMap lt  gt          populate ret          return ret       call Map lt String  Integer gt  map   initializeMap

User · Answer

With Java 8 or less You can use static block to initialize a map with some values  Example   public static Map lt String String gt  test   new HashMap lt String  String gt   static       test put  quot test quot   quot test quot        test put  quot test1 quot   quot test quot       With Java 9 or more You can use Map of   method to initialize a map with some values while declaring  Example   public static Map lt String String gt  test   Map of  quot test quot   quot test quot   quot test1 quot   quot test quot

[java] How to directly initialize a HashMap (in a literal way)?

tl;dr

`Map.of`

`Map.of()`

`Map.of( … )`

`Map.ofEntries( … )`

`Map.copyOf`

Notes

Examples related to java

Examples related to dictionary

Examples related to collections

Examples related to initialization