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

我们使用一个简单的实用程序类以流畅的方式初始化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;
    }
}

我们可以使用具有SimpleEntry的AbstractMap类，该类允许创建不可变映射

Map<String, String> map5 = Stream.of(
    new AbstractMap.SimpleEntry<>("Sakshi","java"),
    new AbstractMap.SimpleEntry<>("fine","python")
    ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    
    System.out.println(map5.get("Sakshi"));
    map5.put("Shiva", "Javascript");
    System.out.println(map5.get("Shiva"));// here we can add multiple entries.

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。

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

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