有没有这样初始化Java HashMap的方法?:
Map<String,String> test =
new HashMap<String, String>{"test":"test","test":"test"};
正确的语法是什么?我没有发现任何与此相关的信息。这可能吗?我正在寻找最短/最快的方法来将一些“最终/静态”值放在地图中,这些值永远不会改变,并且在创建地图时预先知道。
有没有这样初始化Java HashMap的方法?:
Map<String,String> test =
new HashMap<String, String>{"test":"test","test":"test"};
正确的语法是什么?我没有发现任何与此相关的信息。这可能吗?我正在寻找最短/最快的方法来将一些“最终/静态”值放在地图中,这些值永远不会改变,并且在创建地图时预先知道。
当前回答
我们使用一个简单的实用程序类以流畅的方式初始化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<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。
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之后,您有更简单的方法来实现同样的目的。
不幸的是,如果键和值的类型不同,则使用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(仅在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或更低版本
您可以使用静态块用一些值初始化映射。例子:
public static Map<String,String> test = new HashMap<String, String>
static {
test.put("test","test");
test.put("test1","test");
}
使用Java 9或更高版本
在声明时,可以使用Map.of()方法用一些值初始化映射。例子:
public static Map<String,String> test = Map.of("test","test","test1","test");