我怎样才能初始化一个静态的地图？
你将如何初始化Java中的静态地图？
方法一：静态初始化
方法二：实例初始化（匿名子类）还是其他一些方法？
各有什么优点和缺点？
这里是一个例子说明两种方法：
import java.util.HashMap; import java.util.Map; public class Test { private static final Map<Integer, String> myMap = new HashMap<Integer, String>(); static { myMap.put(1, "one"); myMap.put(2, "two"); } private static final Map<Integer, String> myMap2 = new HashMap<Integer, String>(){ { put(1, "one"); put(2, "two"); } }; } 在这种情况下，实例初始化只是语法糖，对吧？ 我不明白你为什么需要一个额外的匿名类来初始化。 如果创建的课程是最终的，那么这将不起作用。
你也可以使用一个静态的初始化器来创建一个不可变的映射：
public class Test { private static final Map<Integer, String> myMap; static { Map<Integer, String> aMap = ....; aMap.put(1, "one"); aMap.put(2, "two"); myMap = Collections.unmodifiableMap(aMap); } }
我喜欢Guava初始化静态，不可变映射的方式：
static final Map<Integer, String> MY_MAP = ImmutableMap.of( 1, "one", 2, "two" );
正如你所看到的，它非常简洁（因为ImmutableMap方便的工厂方法）。
如果您希望地图有超过5个条目，则不能再使用ImmutableMap.of() 。 相反，尝试ImmutableMap.builder()沿着这些行：
static final Map<Integer, String> MY_MAP = ImmutableMap.<Integer, String>builder() .put(1, "one") .put(2, "two") // ... .put(15, "fifteen") .build();
要了解更多关于Guava不可变集合实用程序的好处，请参阅Guava用户指南中的不可变集合解释 。
（的一个子集）番石榴曾经被称为谷歌收藏 。 如果你还没有在你的Java项目中使用这个库，我强烈建议尝试一下！ 正如其他SO用户所认同的 ，Guava已经迅速成为Java最受欢迎和最有用的免费第三方库之一。 （如果你是新手，这个链接背后有一些很好的学习资源。）
更新（2015年） ：至于Java 8 ，那么我仍然会使用番石榴的方法，因为它比任何其他的方式更清洁。 如果你不想要番石榴依赖，考虑一个普通的旧的init方法 。 如果你问我，那么使用二维数组和Stream API的攻击是相当丑陋的，如果你需要创建一个键和值不是相同类型的Map<Integer, String> （例如问题中的Map<Integer, String> ） Map<Integer, String>则会变得更丑。
至于Guava的未来，就Java 8而言，Louis Wasserman在2014年回顾了这个问题 ，并在2016年更新 ，宣布Guava 21将要求并正确地支持Java 8 。
更新（2016） ：正如Tagir Valeev所指出的那样 ， Java 9将最终通过为集合添加便捷工厂方法来清除干净，只使用纯JDK。
static final Map<Integer, String> MY_MAP = Map.of( 1, "one", 2, "two" );
我会用：
public class Test { private static final Map<Integer, String> MY_MAP = createMap(); private static Map<Integer, String> createMap() { Map<Integer, String> result = new HashMap<Integer, String>(); result.put(1, "one"); result.put(2, "two"); return Collections.unmodifiableMap(result); } }
- 它避免了匿名的类，我个人认为这是一个不好的风格，并避免
- 它使得地图的创建更加明确
- 它使地图不可修改
- 因为MY_MAP是不变的，我会把它命名为常量
Java 5提供了更紧凑的语法：
static final Map<String , String> FLAVORS = new HashMap<String , String>() {{ put("Up", "Down"); put("Charm", "Strange"); put("Top", "Bottom"); }};
第二种方法的一个好处是你可以用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!
以下是一个Java 8单行静态映射初始化程序：
private static final Map<String, String> EXTENSION_TO_MIMETYPE = Arrays.stream(new String[][] { { "txt", "text/plain" }, { "html", "text/html" }, { "js", "application/javascript" }, { "css", "text/css" }, { "xml", "application/xml" }, { "png", "image/png" }, { "gif", "image/gif" }, { "jpg", "image/jpeg" }, { "jpeg", "image/jpeg" }, { "svg", "image/svg+xml" }, }).collect(Collectors.toMap(kv -> kv[0], kv -> kv[1]));
编辑：如在问题中初始化Map<Integer, String> ，你需要这样的东西：
static final Map<Integer, String> MY_MAP = Arrays.stream(new Object[][]{ {1, "one"}, {2, "two"}, }).collect(Collectors.toMap(kv -> (Integer) kv[0], kv -> (String) kv[1]));
使用Eclipse Collections （以前的GS Collections ），以下所有内容都可以工作：
import java.util.Map; import org.eclipse.collections.api.map.ImmutableMap; import org.eclipse.collections.api.map.MutableMap; import org.eclipse.collections.impl.factory.Maps; public class StaticMapsTest { private static final Map<Integer, String> MAP = Maps.mutable.with(1, "one", 2, "two"); private static final MutableMap<Integer, String> MUTABLE_MAP = Maps.mutable.with(1, "one", 2, "two"); private static final MutableMap<Integer, String> UNMODIFIABLE_MAP = Maps.mutable.with(1, "one", 2, "two").asUnmodifiable(); private static final MutableMap<Integer, String> SYNCHRONIZED_MAP = Maps.mutable.with(1, "one", 2, "two").asSynchronized(); private static final ImmutableMap<Integer, String> IMMUTABLE_MAP = Maps.mutable.with(1, "one", 2, "two").toImmutable(); private static final ImmutableMap<Integer, String> IMMUTABLE_MAP2 = Maps.immutable.with(1, "one", 2, "two"); }
您还可以使用Eclipse集合静态初始化原始地图。
import org.eclipse.collections.api.map.primitive.ImmutableIntObjectMap; import org.eclipse.collections.api.map.primitive.MutableIntObjectMap; import org.eclipse.collections.impl.factory.primitive.IntObjectMaps; public class StaticPrimitiveMapsTest { private static final MutableIntObjectMap<String> MUTABLE_INT_OBJ_MAP = IntObjectMaps.mutable.<String>empty() .withKeyValue(1, "one") .withKeyValue(2, "two"); private static final MutableIntObjectMap<String> UNMODIFIABLE_INT_OBJ_MAP = IntObjectMaps.mutable.<String>empty() .withKeyValue(1, "one") .withKeyValue(2, "two") .asUnmodifiable(); private static final MutableIntObjectMap<String> SYNCHRONIZED_INT_OBJ_MAP = IntObjectMaps.mutable.<String>empty() .withKeyValue(1, "one") .withKeyValue(2, "two") .asSynchronized(); private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP = IntObjectMaps.mutable.<String>empty() .withKeyValue(1, "one") .withKeyValue(2, "two") .toImmutable(); private static final ImmutableIntObjectMap<String> IMMUTABLE_INT_OBJ_MAP2 = IntObjectMaps.immutable.<String>empty() .newWithKeyValue(1, "one") .newWithKeyValue(2, "two"); }
注意：我是Eclipse集合的提交者
在Java 9中：
private static final Map<Integer, String> MY_MAP = Map.of(1, "one", 2, "two");
详情请参阅JEP 269 。 JDK 9于2017年9月全面上市 。
在这种情况下我永远不会创建一个匿名的子类。 静态初始化器同样适用，如果您想使映射不可修改，例如：
private static final Map<Integer, String> MY_MAP; static { Map<Integer, String>tempMap = new HashMap<Integer, String>(); tempMap.put(1, "one"); tempMap.put(2, "two"); MY_MAP = Collections.unmodifiableMap(tempMap); }
也许看看Google Collections ，例如他们在他们页面上的视频，会很有趣。 他们提供了各种方式来初始化地图和集合，并提供不可变的集合。
更新：这个库现在被命名为番石榴 。
我喜欢匿名课，因为很容易处理它：
public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() { { put(1, "some value"); //rest of code here } });
public class Test { private static final Map<Integer, String> myMap; static { Map<Integer, String> aMap = ....; aMap.put(1, "one"); aMap.put(2, "two"); myMap = Collections.unmodifiableMap(aMap); } }
如果我们声明多于一个常量，那么这个代码将被写入静态块中，并且将来很难维护。 所以最好使用匿名类。
public class Test { public static final Map numbers = Collections.unmodifiableMap(new HashMap(2, 1.0f){ { put(1, "one"); put(2, "two"); } }); }
并建议使用不可修改的地图作为常量，否则它不能被视为常量。
有一个卢克提出的答案 ，它使用Java 8初始化一个地图，但恕我直言，它看起来难看难读。 我们可以创建一个地图条目流。 我们在java.util.AbstractMap已经有两个实现了SimpleEntry和SimpleImmutableEntry的Entry 。 对于这个例子，我们可以使用前者作为：
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));
对于Java 9，我们也可以使用Tagir在他的回答中提到的使用Map.of。
我强烈建议静态块风格的“双大括号初始化”风格。
有人可能会评论说，他们不喜欢匿名的课程，开销，表现等
但是我更多考虑的是代码的可读性和可维护性。 在这个观点上，我站在一个双重大括号是一个更好的代码风格，而不是静态方法。
- 元素是嵌套和内联的。
- 这是更多的面向对象，而不是程序。
- 性能影响非常小，可以忽略。
- 更好的IDE大纲支持（而不是许多匿名静态块）
- 你保存了几行评论，使他们的关系。
- 防止来自异常和字节码优化器的未初始化对象的可能的元素泄露/实例引导。
- 不用担心静态块的执行顺序。
另外，你知道匿名类的GC，你可以使用new HashMap(Map map)把它转换成普通的HashMap。
你可以这样做，直到你面临另一个问题。 如果你这样做，你应该使用完整的另一种编码风格（例如没有静态，工厂类）。
像往常一样apache-commons有适当的方法MapUtils.putAll（Map，Object []） ：
例如，要创建一个颜色映射：
Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] { {"RED", "#FF0000"}, {"GREEN", "#00FF00"}, {"BLUE", "#0000FF"} });
你正在创建的匿名类运作良好。 但是，您应该知道这是一个内部类，因此它将包含对周围类实例的引用。 所以你会发现你不能用它做某些事情（使用XStream ）。 你会得到一些非常奇怪的错误。
话虽如此，只要你知道，那么这种方法是好的。 我大部分时间都是以简明的方式使用它来初始化各种各样的藏品。
编辑：正确地指出这是一个静态类的评论。 显然我没有仔细阅读。 然而，我的意见仍然适用于匿名内部类。
如果你想要一些简洁和相对安全的东西，你可以把编译时类型检查转移到运行时：
static final Map<String, Integer> map = MapUtils.unmodifiableMap( String.class, Integer.class, "cat", 4, "dog", 2, "frog", 17 );
这个实现应该捕获任何错误：
import java.util.HashMap; public abstract class MapUtils { private MapUtils() { } public static <K, V> HashMap<K, V> unmodifiableMap( Class<? extends K> keyClazz, Class<? extends V> valClazz, Object...keyValues) { return Collections.<K, V>unmodifiableMap(makeMap( keyClazz, valClazz, keyValues)); } public static <K, V> HashMap<K, V> makeMap( Class<? extends K> keyClazz, Class<? extends V> valClazz, Object...keyValues) { if (keyValues.length % 2 != 0) { throw new IllegalArgumentException( "'keyValues' was formatted incorrectly! " + "(Expected an even length, but found '" + keyValues.length + "')"); } HashMap<K, V> result = new HashMap<K, V>(keyValues.length / 2); for (int i = 0; i < keyValues.length;) { K key = cast(keyClazz, keyValues[i], i); ++i; V val = cast(valClazz, keyValues[i], i); ++i; result.put(key, val); } return result; } private static <T> T cast(Class<? extends T> clazz, Object object, int i) { try { return clazz.cast(object); } catch (ClassCastException e) { String objectName = (i % 2 == 0) ? "Key" : "Value"; String format = "%s at index %d ('%s') wasn't assignable to type '%s'"; throw new IllegalArgumentException(String.format(format, objectName, i, object.toString(), clazz.getSimpleName()), e); } } }
我更喜欢使用静态初始化器来避免生成匿名类（这将没有更多的目的），所以我会列出使用静态初始化器进行初始化的技巧。 所有列出的解决方案/提示都是类型安全的。
注意：这个问题没有提到让地图变得不可修改的问题，所以我将把它留在外面，但是要知道，使用Collections.unmodifiableMap(map)可以轻松完成。
第一个提示
第一个技巧是你可以对地图进行本地引用，并给它一个简短的名字：
private static final Map<Integer, String> myMap = new HashMap<>(); static { final Map<Integer, String> m = myMap; // Use short name! m.put(1, "one"); // Here referencing the local variable which is also faster! m.put(2, "two"); m.put(3, "three"); }
第二个提示
第二个技巧是你可以创建一个辅助方法来添加条目; 如果您想要，也可以公开这个辅助方法：
private static final Map<Integer, String> myMap2 = new HashMap<>(); static { p(1, "one"); // Calling the helper method. p(2, "two"); p(3, "three"); } private static void p(Integer k, String v) { myMap2.put(k, v); }
这里的helper方法不可重用，因为它只能添加元素到myMap2 。 为了使其可重用，我们可以将映射本身作为辅助方法的一个参数，但是初始化代码不会更短。
第三个提示
第三个技巧是你可以使用填充功能创建一个可重用的builder-like助手类。 这真的是一个简单的10行辅助类，它是类型安全的：
public class Test { private static final Map<Integer, String> myMap3 = new HashMap<>(); static { new B<>(myMap3) // Instantiating the helper class with our map .p(1, "one") .p(2, "two") .p(3, "three"); } } class B<K, V> { private final Map<K, V> m; public B(Map<K, V> m) { this.m = m; } public B<K, V> p(K k, V v) { m.put(k, v); return this; // Return this for chaining } }
当我不想（或不能）使用Guava的ImmutableMap.of() ，或者如果我需要一个可变的Map时，这是我的最爱：
public static <A> Map<String, A> asMap(Object... keysAndValues) { return new LinkedHashMap<String, A>() {{ for (int i = 0; i < keysAndValues.length - 1; i++) { put(keysAndValues[i].toString(), (A) keysAndValues[++i]); } }}; }
它非常紧凑，它忽略了杂散值（即没有价值的最终密钥）。
用法：
Map<String, String> one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal"); Map<String, Object> two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2));
您可以使用StickyMap和MapEntry ：
private static final Map<String, String> MAP = new StickyMap<>( new MapEntry<>("name", "Jeffrey"), new MapEntry<>("age", "35") );
我不喜欢静态初始化语法，我不相信匿名子类。 一般来说，我同意使用静态初始值设定项的所有缺点，以及使用前面答案中提到的匿名子类的所有缺点。 另一方面，在这些职位上提出的专业人士是不够的。 我更喜欢使用静态初始化方法：
public class MyClass { private static final Map<Integer, String> myMap = prepareMap(); private static Map<Integer, String> prepareMap() { Map<Integer, String> hashMap = new HashMap<>(); hashMap.put(1, "one"); hashMap.put(2, "two"); return hashMap; } }
由于Java不支持地图文字，地图实例必须始终显式实例化和填充。
幸运的是，可以使用工厂方法近似Java中的地图文字的行为。
例如：
public class LiteralMapFactory { // Creates a map from a list of entries @SafeVarargs public static <K, V> Map<K, V> mapOf(Map.Entry<K, V>... entries) { LinkedHashMap<K, V> map = new LinkedHashMap<>(); for (Map.Entry<K, V> entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; } // Creates a map entry public static <K, V> Map.Entry<K, V> entry(K key, V value) { return new AbstractMap.SimpleEntry<>(key, value); } public static void main(String[] args) { System.out.println(mapOf(entry("a", 1), entry("b", 2), entry("c", 3))); } }
输出：
{a = 1，b = 2，c = 3}
这比一次创建和填充地图要方便得多。
在Java 8中，我使用了以下模式：
private static final Map<String, Integer> MAP = Stream.of( new AbstractMap.SimpleImmutableEntry<>("key1", 1), new AbstractMap.SimpleImmutableEntry<>("key2", 2) ).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
这不是最简洁和有点迂回，但是
- 它不需要
java.util之外的任何东西 - 它是类型安全的，容易适应不同类型的关键和价值。
那么…我喜欢枚举;）
enum MyEnum { ONE (1, "one"), TWO (2, "two"), THREE (3, "three"); int value; String name; MyEnum(int value, String name) { this.value = value; this.name = name; } static final Map<Integer, String> MAP = Stream.of( values() ) .collect( Collectors.toMap( e -> e.value, e -> e.name ) ); }
第二种方法可以根据需要调用受保护的方法。 这可以用于初始化构建后不可变的类。
我喜欢匿名类的语法; 它只是少了一些代码。 但是，我发现的一个主要的问题是，您将无法通过远程序列化该对象。 你会得到一个异常，无法找到远程端的匿名类。
我做了一些不同的事情。 不是最好的，但它适用于我。 也许它可以“通用化”。
private static final Object[][] ENTRIES = { {new Integer(1), "one"}, {new Integer(2), "two"}, }; private static final Map myMap = newMap(ENTRIES); private static Map newMap(Object[][] entries) { Map map = new HashMap(); for (int x = 0; x < entries.length; x++) { Object[] entry = entries[x]; map.put(entry[0], entry[1]); } return map; }
现在Java 8已经出来了，这个问题值得重温。 我采取了刺戳 – 看起来也许你可以利用lambda表达式语法来得到一个相当不错的简洁（但类型安全）的地图文字语法，看起来像这样：
Map<String,Object> myMap = hashMap( bob -> 5, TheGimp -> 8, incredibleKoolAid -> "James Taylor", heyArnold -> new Date() ); Map<String,Integer> typesafeMap = treeMap( a -> 5, bee -> 8, sea -> 13 deep -> 21 );
未经测试的示例代码在https://gist.github.com/galdosd/10823529会好奇别人的意见在这（这是温和的邪恶;…）
我喜欢使用静态初始化“技术”，当我有一个抽象类的具体实现已经定义了初始化构造函数，但没有默认的构造函数，但我希望我的子类有一个默认的构造函数。
例如：
public abstract class Shape { public static final String COLOR_KEY = "color_key"; public static final String OPAQUE_KEY = "opaque_key"; private final String color; private final Boolean opaque; /** * Initializing constructor - note no default constructor. * * @param properties a collection of Shape properties */ public Shape(Map<String, Object> properties) { color = ((String) properties.getOrDefault(COLOR_KEY, "black")); opaque = (Boolean) properties.getOrDefault(OPAQUE_KEY, false); } /** * Color property accessor method. * * @return the color of this Shape */ public String getColor() { return color; } /** * Opaque property accessor method. * * @return true if this Shape is opaque, false otherwise */ public Boolean isOpaque() { return opaque; } }
和我这个类的具体实现 – 但它需要/需要一个默认的构造函数：
public class SquareShapeImpl extends Shape { private static final Map<String, Object> DEFAULT_PROPS = new HashMap<>(); static { DEFAULT_PROPS.put(Shape.COLOR_KEY, "yellow"); DEFAULT_PROPS.put(Shape.OPAQUE_KEY, false); } /** * Default constructor -- intializes this square to be a translucent yellow */ public SquareShapeImpl() { // the static initializer was useful here because the call to // this(...) must be the first statement in this constructor // ie, we can't be mucking around and creating a map here this(DEFAULT_PROPS); } /** * Initializing constructor -- create a Square with the given * collection of properties. * * @param props a collection of properties for this SquareShapeImpl */ public SquareShapeImpl(Map<String, Object> props) { super(props); } }
then to use this default constructor, we simply do:
public class StaticInitDemo { public static void main(String[] args) { // create a translucent, yellow square... Shape defaultSquare = new SquareShapeImpl(); // etc... } }
I have not seen the approach I use (and have grown to like) posted in any answers, so here it is:
I don't like using static initializers because they are clunky, and I don't like anonymous classes because it is creating a new class for each instance.
instead, I prefer initialization that looks like this:
map( entry("keyA", "val1"), entry("keyB", "val2"), entry("keyC", "val3") );
unfortunately, these methods are not part of the standard Java library, so you will need to create (or use) a utility library that defines the following methods:
public static <K,V> Map<K,V> map(Map.Entry<K, ? extends V>... entries) public static <K,V> Map.Entry<K,V> entry(K key, V val)
(you can use 'import static' to avoid needing to prefix the method's name)
I found it useful to provide similar static methods for the other collections (list, set, sortedSet, sortedMap, etc.)
Its not quite as nice as json object initialization, but it's a step in that direction, as far as readability is concerned.
