我们使用一个简单的实用程序类以流畅的方式初始化Maps：

Map<String, String> map = MapInit
    .init("key1", "value1")
    .put("key2", "value2")
    .put("key3", "value3")
    .getMap();

实用程序类不受键和值的类型、条目的数量以及生成的Map的类型的限制。

实用程序类如下所示：

public class MapInit<K, V, T extends Map<K, V>> {
    private final T map;


    private MapInit(final T map) {
        this.map = map;
    }

    public T getMap() {
        return this.map;
    }

    public static <K, V> MapInit<K, V, HashMap<K, V>> init(final K key, final V value) {
        return init(HashMap::new, key, value);
    }

    public static <K, V, T extends Map<K, V>> MapInit<K, V, T> init(final Supplier<T> mapSupplier, final K key, final V value) {
        return new MapInit<>(mapSupplier.get()) //
                .put(key, value);
    }

    public MapInit<K, V, T> put(final K key, final V value) {
        this.map.put(key, value);
        return this;
    }
}

您可以通过两种简单的方式轻松地创建自己的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)));
    }};
}

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

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之后，您有更简单的方法来实现同样的目的。

没有直接的方法可以做到这一点——截至2021，Java没有Map文字（然而，我认为它们是为Java8提出的，但没有实现）。

有些人喜欢这样：

Map<String,String> test = new HashMap<String, String>(){{
       put("test","test"); put("test","test");}};

这将创建HashMap的匿名子类，其实例初始值设定项将放置这些值。（顺便说一句，地图不能包含两个相同的值，第二个put将覆盖第一个。我将在下一个示例中使用不同的值。）

通常的方法是（对于局部变量）：

Map<String,String> test = new HashMap<String, String>();
test.put("test","test");
test.put("test1","test2");

如果测试映射是实例变量，请将初始化放在构造函数或实例初始值设定项中：

Map<String,String> test = new HashMap<String, String>();
{
    test.put("test","test");
    test.put("test1","test2");
}

如果测试映射是类变量，请将初始化放在静态初始值设定项中：

static Map<String,String> test = new HashMap<String, String>();
static {
    test.put("test","test");
    test.put("test1","test2");
}

如果你希望你的映射永远不变，你应该在初始化后用Collections.unmodifiedMap（…）包装你的映射。你也可以在静态初始化器中这样做：

static Map<String,String> test;
{
    Map<String,String> temp = new HashMap<String, String>();
    temp.put("test","test");
    temp.put("test1","test2");
    test = Collections.unmodifiableMap(temp);
}

（我不确定你现在是否能让考试成为最终……试试看，然后在这里报告。）

从Java9开始，您还拥有Map.of（…）和Map.entries（）语法，正如yankee的回答所解释的。

不幸的是，如果键和值的类型不同，则使用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，但由于它是一个接口，所以它需要一个实现类和/或一个助手工厂方法。它也不是不可变的，并且包含对该任务不有用的其他逻辑。）

另一种方法是使用纯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");