Java 如何直接初始化HashMap（以文本方式）？

有没有像这样初始化Java HashMap的方法

Map<String,String> test = 
    new HashMap<String, String>{"test":"test","test":"test"};

Map测试=
新的HashMap{“test”：“test”，“test”：“test”}；

正确的语法是什么？我没有发现任何关于这个的东西。这可能吗？我正在寻找最短/最快的方法将一些“最终/静态”值放入地图中，这些值在创建地图时永远不会更改，并且是预先知道的。

所有版本 如果您碰巧只需要一个条目：有

集合。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")
);

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

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

使用函数进行初始化还可以使您在初始值设定项中生成映射，但可以避免令人讨厌的副作用：

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

Map myMap=createMap（）；
私有静态映射createMap（）{
Map myMap=newhashmap（）；
myMap.put（“a”、“b”）；
myMap.put（“c”、“d”）；
返回myMap；
}

这是一种方法

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

maph=newhashmap（）{{
付诸表决（“a”、“b”）；
}};

但是，您应该小心并确保理解上述代码（它创建了一个从HashMap继承的新类）。因此，您应该在此处阅读更多内容： ，或简单地使用番石榴：

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

Map left=ImmutableMap.of（“a”，1，“b”，2，“c”，3）；

ImmutableMap.of

最多可用于5个条目。否则，请使用生成器：。

Map test=newhashmap（）
{
{
put（键1，值1）；
put（键2，值2）；
}
};

没有直接的方法可以做到这一点-Java没有映射文本（但是-我认为它们是为Java 8提出的）

有些人喜欢这样：

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

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

如果

test

map是类变量，则将初始化放在静态初始值设定项中：

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

---

（我不确定您现在是否可以进行

测试

最终…在此处尝试并报告。）

如果您允许第三方LIB，您可以使用来实现文字简洁：

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

Map test=ImmutableMap.of（“k1”、“v1”、“k2”、“v2”）；

此选项最多适用于，否则您可以使用其：

Map test=ImmutableMap.builder（）
.put（“k1”、“v1”）
.put（“k2”、“v2”）
...
.build（）；

• 注意，Guava的实现不同于Java的实现（最值得注意的是它是不可变的，不允许空键/值）
• 有关更多信息，请参阅Guava网站上的用户指南文章

---

另一种方法是使用普通Java 7类和varargs：使用以下方法创建类

HashMapBuilder

：

公共静态HashMap构建（字符串…数据）{
HashMap结果=新建HashMap（）；
如果（数据长度%2！=0）
抛出新的IllegalArgumentException（“奇数个参数”）；
字符串键=null；
整数步长=-1；
for（字符串值：数据）{
step++；
开关（步骤%2）{
案例0：
如果（值==null）
抛出新的IllegalArgumentException（“Null键值”）；
键=值；
继续；
案例1：
结果。输入（键、值）；
打破
}
}
返回结果；
}

使用如下方法：

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

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

HashMap data=HashMapBuilder.build（“key1”、“value1”、“key2”、“value2”）；

tl；博士 在Java9和更高版本中使用

Map.of…

方法

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

Map.of（）

创建一个空的

映射

。不可修改，因此无法添加条目。下面是这样一个映射的示例，它是空的，没有条目

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

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

toString（）：{SUNDAY=Person{name='Bob'}，SUNDAY=Person{name='Alice'}

入口地图（…）

获取实现接口的任意数量的对象。Java捆绑了两个实现该接口的类，一个是可变的，另一个是不可变的：。但我们不需要指定具体的类。我们只需要调用方法，传递键和值，然后返回某个类实现接口的对象

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

MapweekdayWorker=Map.ofEntries(
Map.entry（DayOfWeek.MONDAY，alice），//调用'Map.entry'方法返回实现'Map.entry'的对象。
地图入口（星期二，鲍勃），
地图入口（星期三，鲍勃），
地图入口（星期四，卡罗尔），
地图入口（卡罗尔，星期五，星期五）
);

weekdayWorker.toString（）：{星期三=人{name='Bob'}，星期二=人{name='Bob'}，星期四=人{name='Carol'}，星期五=人{name='Carol'}，星期一=人{name='Alice'}

Map.copyOf

Java10添加了这个方法。传递现有映射，然后获取该映射的不可变副本

笔记 请注意，不能保证通过

Map.of

生成的映射的迭代器顺序。条目具有任意顺序。不要根据所看到的顺序编写代码，因为文档警告该顺序可能会更改

---

注意，所有这些…方法的

Map.of…

方法返回一个未指定类的。底层的具体类甚至可能因Java的不同版本而异。这种匿名性使Java能够从各种实现中选择最适合您的特定数据的实现。例如，如果您的密钥来自，Java可能会使用一种隐藏的方法。

您可以创建自己的

映射（仅在Java 9及更高版本中可用）方法
Map< String , String > animalSounds =
    Map.of(
        "dog"  , "bark" ,   // key , value
        "cat"  , "meow" ,   // key , value
        "bird" , "chirp"    // key , value
    )
;

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

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

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

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

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

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

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

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

@Test
public void whenInitializeUnmodifiableSetWithDoubleBrace_containsElements() {
    Set<String> countries = Stream.of("India", "USSR", "USA")
      .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));

    assertTrue(countries.contains("India"));
}

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;

Map<String, Integer> initializeMap()
{
  Map<String, Integer> ret = new HashMap<>();

  //populate ret
  ...

  return ret;
}

//call
Map<String, Integer> map = initializeMap();

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.

 hashMap.put("hcl", "amit");

 hashMap.put("tcs","ravi");

    Map<String, String> hashMap = new HashMap<String, String>(3);
    hashMap.put("virat", "cricket");
    hashMap.put("amit","football");

  Map<String, String> immutableMap = Collections.singletonMap("rohit", 
       "cricket");

  Map<String, String> emptyMap = Collections.emptyMap();

   Map<String, String> map = new HashMap<String, String>() {{
     put("hcl", "amit");
     put("tcs","ravi");
     put("wipro","anmol");
    }};

Map<String, String> myMap = Stream.of(
         new SimpleEntry<>("key1", "value1"),
         new SimpleEntry<>("key2", (String) null),
         new SimpleEntry<>("key3", "value3"))
        .collect(HashMap::new,
                (map, entry) -> map.put(entry.getKey(),
                                        entry.getValue()),
                HashMap::putAll);

Map<String, Integer> map = Stream.of(new Object[][] { 
     { "data1", 1 }, 
     { "data2", 2 }, 
 }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));

public static Map<String, String> mapWithValues(String...values) {
    Map<String, String> map = new HashMap<String, String>();
    
    for (int x = 0; x < values.length; x = x+2) {
        map.put(values[x], values[x+1]);
    }
    
    return map;
}