如何在Java中初始化一个静态Map ?
方法一:静态初始化器 方法二:实例初始化器(匿名子类) 或 还有别的方法吗?
它们各自的优点和缺点是什么?
下面是一个例子来说明这两种方法:
import java.util.HashMap;
import java.util.Map;
public class Test {
private static final Map<Integer, String> myMap = new HashMap<>();
static {
myMap.put(1, "one");
myMap.put(2, "two");
}
private static final Map<Integer, String> myMap2 = new HashMap<>(){
{
put(1, "one");
put(2, "two");
}
};
}
当前回答
和往常一样，apache-commons有合适的方法MapUtils。putAll(地图、对象[]):
例如，要创建一个彩色地图:
Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
{"RED", "#FF0000"},
{"GREEN", "#00FF00"},
{"BLUE", "#0000FF"}
});
其他回答
第二个方法的一个优点是，你可以用Collections.unmodifiableMap()来包装它，以确保以后不会更新集合:
private static final Map<Integer, String> CONSTANT_MAP =
Collections.unmodifiableMap(new HashMap<Integer, String>() {{
put(1, "one");
put(2, "two");
}});
// later on...
CONSTANT_MAP.put(3, "three"); // going to throw an exception!
我已经读了答案，我决定写我自己的地图生成器。请随意复制粘贴并欣赏。
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* A tool for easy creation of a map. Code example:<br/>
* {@code MapBuilder.of("name", "Forrest").and("surname", "Gump").build()}
* @param <K> key type (inferred by constructor)
* @param <V> value type (inferred by constructor)
* @author Vlasec (for http://stackoverflow.com/a/30345279/1977151)
*/
public class MapBuilder <K, V> {
private Map<K, V> map = new HashMap<>();
/** Constructor that also enters the first entry. */
private MapBuilder(K key, V value) {
and(key, value);
}
/** Factory method that creates the builder and enters the first entry. */
public static <A, B> MapBuilder<A, B> mapOf(A key, B value) {
return new MapBuilder<>(key, value);
}
/** Puts the key-value pair to the map and returns itself for method chaining */
public MapBuilder<K, V> and(K key, V value) {
map.put(key, value);
return this;
}
/**
* If no reference to builder is kept and both the key and value types are immutable,
* the resulting map is immutable.
* @return contents of MapBuilder as an unmodifiable map.
*/
public Map<K, V> build() {
return Collections.unmodifiableMap(map);
}
}
编辑:最近，我经常发现公共静态方法，我有点喜欢它。我将它添加到代码中，并使构造函数私有，从而切换到静态工厂方法模式。
EDIT2:甚至最近，我不再喜欢被称为of的静态方法，因为它在使用静态导入时看起来非常糟糕。我将其重命名为mapOf，使其更适合静态导入。
Java 9
我们可以用地图。ofEntries，调用Map。条目(k, v)来创建每个条目。
import static java.util.Map.entry;
private static final Map<Integer,String> map = Map.ofEntries(
entry(1, "one"),
entry(2, "two"),
entry(3, "three"),
entry(4, "four"),
entry(5, "five"),
entry(6, "six"),
entry(7, "seven"),
entry(8, "eight"),
entry(9, "nine"),
entry(10, "ten"));
我们也可以使用Map。如Tagir在他的回答中所建议的，但我们不能使用Map.of有超过10个条目。
Java 8
我们可以创建一个映射条目流。在java.util.AbstractMap中我们已经有两个Entry的实现，它们是SimpleEntry和SimpleImmutableEntry。在这个例子中，我们可以使用former as:
import java.util.AbstractMap.*;
private static final Map<Integer, String> myMap = Stream.of(
new SimpleEntry<>(1, "one"),
new SimpleEntry<>(2, "two"),
new SimpleEntry<>(3, "three"),
new SimpleEntry<>(4, "four"),
new SimpleEntry<>(5, "five"),
new SimpleEntry<>(6, "six"),
new SimpleEntry<>(7, "seven"),
new SimpleEntry<>(8, "eight"),
new SimpleEntry<>(9, "nine"),
new SimpleEntry<>(10, "ten"))
.collect(Collectors.toMap(SimpleEntry::getKey, SimpleEntry::getValue));
这里是算盘常用的代码
Map<Integer, String> map = N.asMap(1, "one", 2, "two");
// Or for Immutable map
ImmutableMap<Integer, String> = ImmutableMap.of(1, "one", 2, "two");
声明:我是普通算盘的开发者。
如果你只需要向映射中添加一个值，你可以使用Collections.singletonMap:
Map<K, V> map = Collections.singletonMap(key, value)
