如果它是一个实例变量，那么一个实例初始化块绝对是最好的方法，特别是如果你不能使用Map.of（），因为你需要一个不同类型的映射。

但是，如果你感觉很活泼，你可以使用Java 8供应商（不推荐）。

private final Map<String,Runnable> games = ((Supplier<Map<String,Runnable>>)() -> {
  Map<String,Runnable> map = new LinkedHashMap<>();

  map.put("solarus",this::playSolarus);
  map.put("lichess",this::playLichess);

  return map;
}).get();

或者制作自己的功能界面（我觉得不错）：

@FunctionalInterface
public interface MapMaker<M> {
  static <M extends Map<K,V>,K,V> M make(M map,MapMaker<M> maker) {
    maker.build(map);
    return map;
  }

  void build(M map);
}

// Can use LinkedHashMap!
private final Map<String,Runnable> games = MapMaker.make(
    new LinkedHashMap<>(),(map) -> {
      map.put("solarus",this::playSolarus);
      map.put("lichess",this::playLichess);
    });

这是一种方式。

Map<String, String> h = new HashMap<String, String>() {{
    put("a","b");
}};

但是，您应该小心并确保您理解以上代码（它创建了一个继承自HashMap的新类）。因此，您应该在此处阅读更多信息：http://www.c2.com/cgi/wiki?DoubleBraceInitialization，或仅使用Guava：

Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);

ImmutableMap.of最多可用于5个条目。否则，使用builder:source。

tl；博士

在Java 9和更高版本中使用Map.of…方法。

Map< String , String > animalSounds =
    Map.of(
        "dog"  , "bark" ,   // key , value
        "cat"  , "meow" ,   // key , value
        "bird" , "chirp"    // key , value
    )
;

地图of

Java9添加了一系列Map.of静态方法，以满足您的需要：使用文本语法实例化不可变的Map。

映射（条目集合）是不可变的，因此在实例化后不能添加或删除条目。此外，每个条目的键和值是不可变的，不能更改。有关其他规则，请参见Javadoc，例如不允许NULL，不允许重复键，映射的迭代顺序是任意的。

让我们看看这些方法，使用一些示例数据绘制一张一周中某一天的地图，以显示我们希望该天工作的人。

Person alice = new Person( "Alice" );
Person bob = new Person( "Bob" );
Person carol = new Person( "Carol" );

映射.of（）

Map.of创建一个空的Map。无法修改，因此无法添加条目。下面是这样一个地图的示例，空的没有条目。

Map < DayOfWeek, Person > dailyWorkerEmpty = Map.of();

dailyWorkerEmpty.toString（）：｛｝

第页，共页（…）

Map.of（k，v，k，v…）是几个方法，需要1到10个键值对。下面是两个条目的示例。

Map < DayOfWeek, Person > weekendWorker = 
        Map.of( 
            DayOfWeek.SATURDAY , alice ,     // key , value
            DayOfWeek.SUNDAY , bob           // key , value
        )
;

weekendWorker.toString（）：｛SUNDAY=人｛name=“Bob”｝，星期六=人｛name=“虱子”｝｝

项目地图（…）

条目的Map.Entries（Map.Entry，…）采用实现Map.Entrey接口的任意数量的对象。Java捆绑了两个实现该接口的类，一个是可变的，另一个是不可变的：AbstractMap.SimpleEntry，AbstractMap.SimpleModuleEntry。但是我们不需要指定具体的类。我们只需要调用Map.entry（k，v）方法，传递键和值，然后返回实现Map.entry接口的某个类的对象。

Map < DayOfWeek, Person > 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（）：｛星期三=人｛name＝‘Bob’｝，星期二=人{name＝“Bob”｝，周四=人{name＝‘Carol’｝、星期五=人{name=‘Carol‘｝，周一=人｛name＝‘虱子’｝

地图副本

Java10添加了Map.copyOf方法。传递现有的映射，获取该映射的不可变副本。

笔记

注意，不能保证通过Map.of生成的映射的迭代器顺序。条目具有任意顺序。不要根据看到的顺序编写代码，因为文档警告顺序可能会更改。

注意，所有这些Map.of…方法都返回未指定类的Map。底层的具体类甚至可能因Java的不同版本而异。这种匿名性使Java能够从各种实现中选择最适合您特定数据的实现。例如，如果您的键来自枚举，Java可能会在封面下使用EnumMap。

另一种方法是使用纯Java 7类和varargs：使用以下方法创建一个类HashMapBuilder：

public static HashMap<String, String> build(String... data){
    HashMap<String, String> result = new HashMap<String, String>();

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

使用如下方法：

HashMap<String,String> data = HashMapBuilder.build("key1","value1","key2","value2");

我找到了baeldung的一篇很棒的文章，其中列出了在不同Java版本中实现这一点的几种方法。

有几个有趣的方法很方便

对于任何Java版本

public static Map<String, String> articleMapOne;
static {
    articleMapOne = new HashMap<>();
    articleMapOne.put("ar01", "Intro to Map");
    articleMapOne.put("ar02", "Some article");
}

对于使用流的Java 8

Map<String, String> map = Stream.of(new String[][] {
  { "Hello", "World" }, 
  { "John", "Doe" }, 
}).collect(Collectors.toMap(data -> data[0], data -> data[1]));

JAVA 8

在普通的java8中，您还可以使用Streams/Collectors来完成这项工作。

Map<String, String> myMap = Stream.of(
         new SimpleEntry<>("key1", "value1"),
         new SimpleEntry<>("key2", "value2"),
         new SimpleEntry<>("key3", "value3"))
        .collect(toMap(SimpleEntry::getKey, SimpleEntry::getValue));

这具有不创建匿名类的优点。

请注意，进口产品包括：

import static java.util.stream.Collectors.toMap;
import java.util.AbstractMap.SimpleEntry;

当然，正如在其他答案中所指出的，在java9之后，您有更简单的方法来实现同样的目的。