Map<String,String> test = new HashMap<String, String>()
{
    {
        put(key1, value1);
        put(key2, value2);
    }
};

您可以通过两种简单的方式轻松地创建自己的Map.of（仅在Java9及更高版本中可用）方法

使用设定数量的参数

实例

public <K,V> Map<K,V> mapOf(K k1, V v1, K k2, V v2 /* perhaps more parameters */) {
    return new HashMap<K, V>() {{
      put(k1, v1);
      put(k2,  v2);
      // etc...
    }};
}

使用列表制作

您也可以使用列表来实现这一点，而不是为某一组参数创建许多方法。

实例

public <K, V> Map<K, V> mapOf(List<K> keys, List<V> values) {
   if(keys.size() != values.size()) {
        throw new IndexOutOfBoundsException("amount of keys and values is not equal");
    }

    return new HashMap<K, V>() {{
        IntStream.range(0, keys.size()).forEach(index -> put(keys.get(index), values.get(index)));
    }};
}

笔记不建议将其用于所有对象，因为每次使用时都会生成一个匿名类。

所有版本

如果您恰好需要一个条目：Collections.singletonMap（“key”，“value”）。

对于Java版本9或更高版本：

是的，这现在是可能的。在Java 9中，添加了两种简化地图创建的工厂方法：

// this works for up to 10 elements:
Map<String, String> test1 = Map.of(
    "a", "b",
    "c", "d"
);

// this works for any number of elements:
import static java.util.Map.entry;    
Map<String, String> test2 = Map.ofEntries(
    entry("a", "b"),
    entry("c", "d")
);

在上面的示例中，test和test2都是相同的，只是表示Map的方式不同。Map.of方法最多为映射中的十个元素定义，而Map.ofEntries方法没有这样的限制。

注意，在这种情况下，生成的映射将是一个不可变的映射。如果希望映射是可变的，可以再次复制它，例如使用mutableMap=newHashMap<>（map.of（“a”，“b”））；。还要注意，在这种情况下，键和值不能为空。

（另见JEP 269和Javadoc）

对于Java版本8之前的版本：

否，您必须手动添加所有元素。您可以在匿名子类中使用初始值设定项，使语法稍短：

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

然而，在某些情况下，匿名子类可能会引入不需要的行为。这包括例如：

它生成了一个额外的类，增加了内存消耗、磁盘空间消耗和启动时间在非静态方法的情况下：它保存对调用创建方法的对象的引用。这意味着当创建的映射对象仍然被引用时，不能对外部类的对象进行垃圾收集，从而阻塞了额外的内存

使用函数进行初始化也将使您能够在初始值设定项中生成映射，但避免了严重的副作用：

Map<String, String> myMap = createMap();

private static Map<String, String> createMap() {
    Map<String,String> myMap = new HashMap<String,String>();
    myMap.put("a", "b");
    myMap.put("c", "d");
    return myMap;
}

如果您允许第三方库，您可以使用Guava的ImmutableMap来实现字面上的简洁：

Map<String, String> test = ImmutableMap.of("k1", "v1", "k2", "v2");

这最多适用于5个键/值对，否则您可以使用其生成器：

Map<String, String> test = ImmutableMap.<String, String>builder()
    .put("k1", "v1")
    .put("k2", "v2")
    ...
    .build();

注意，Guava的ImmutableMap实现与Java的HashMap实现不同（最明显的是它是不可变的，不允许空键/值）有关更多信息，请参阅Guava关于其不可变集合类型的用户指南文章

不幸的是，如果键和值的类型不同，则使用varargs不是很合理，因为您必须使用Object。。。并且完全失去类型安全性。如果你总是想创建一个Map＜String，String＞，当然可以创建一个toMap（String…args），但不是很漂亮，因为它很容易混淆键和值，奇数个参数是无效的。

您可以创建HashMap的子类，该子类具有可链接的方法，如

public class ChainableMap<K, V> extends HashMap<K, V> {
  public ChainableMap<K, V> set(K k, V v) {
    put(k, v);
    return this;
  }
}

并像使用新的ChainableMap<String，Object>（）.set（“a”，1）.set“b”，“foo”）一样使用它

另一种方法是使用通用生成器模式：

public class MapBuilder<K, V> {
  private Map<K, V> mMap = new HashMap<>();

  public MapBuilder<K, V> put(K k, V v) {
    mMap.put(k, v);
    return this;
  }

  public Map<K, V> build() {
    return mMap;
  }
}

并像新的MapBuilder＜String，Object＞（）.put（“a”，1）.pput（“b”，“foo”）.build（）那样使用它；

然而，我经常使用的解决方案使用varargs和Pair类：

public class Maps {
  public static <K, V> Map<K, V> of(Pair<K, V>... pairs) {
    Map<K, V> = new HashMap<>();

    for (Pair<K, V> pair : pairs) {
      map.put(pair.first, pair.second);
    }

    return map;
  }
}

Map<String，Object>Map=Maps.of（Pair.create（“a”，1），Pair.create（“b”，“foo”）；

Pair.create（）的冗长让我有点困扰，但这很好。如果您不介意静态导入，当然可以创建一个助手：

public <K, V> Pair<K, V> p(K k, V v) {
  return Pair.create(k, v);
}

Map<String，Object>Map=Map.of（p（“a”，1），p（“b”，“foo”）；

（人们可以想象使用Map.Entry来代替Pair，但由于它是一个接口，所以它需要一个实现类和/或一个助手工厂方法。它也不是不可变的，并且包含对该任务不有用的其他逻辑。）

如果它是一个实例变量，那么一个实例初始化块绝对是最好的方法，特别是如果你不能使用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);
    });