如何初始化静态地图？

我喜欢Guava初始化静态不可变映射的方法:

static final Map MY_MAP = ImmutableMap.of(
    1, "one",
    2, "two"
);

如您所见,它非常简洁(因为方便的工厂方法ImmutableMap).

如果您希望地图有超过5个条目,则无法再使用ImmutableMap.of().相反,尝试ImmutableMap.builder()以下这些方面:

static final Map MY_MAP = ImmutableMap.builder()
    .put(1, "one")
    .put(2, "two")
    // ... 
    .put(15, "fifteen")
    .build();

要了解更多有关的番石榴的不可变集合实用工具的好处,看到解释不可改变的集合番石榴用户指南中.

(其中一部分)Guava曾被称为Google Collections.如果您尚未在Java项目中使用此库,我强烈建议您尝试使用它!正如SO用户所认同的那样,Guava已经迅速成为Java最受欢迎和最有用的免费第三方库之一.(如果您是新手,那么该链接背后有一些优秀的学习资源.)

更新(2015):至于Java 8,我仍然会使用Guava方法,因为它比其他任何方式更清洁.如果您不想要Guava依赖,请考虑一个普通的旧init方法.如果你问我,那么带有二维数组和Stream API的hack 非常难看,如果你需要创建一个键和值不是同一类型的Map(比如Map问题),那么它会变得更加丑陋.

至于番石榴的未来,就Java 8而言,Louis Wasserman 早在2014 年就已经说过,并且在2016年[ 更新 ]宣布Guava 21将要求并正确支持Java 8.

更新(2016):正如Tagir Valeev所指出的那样,Java 9最终会通过为集合添加便利工厂方法来使用纯粹的JDK.

static final Map MY_MAP = Map.of(
    1, "one", 
    2, "two"
);

Java 5提供了这种更紧凑的语法:

static final Map FLAVORS = new HashMap() {{
    put("Up",    "Down");
    put("Charm", "Strange");
    put("Top",   "Bottom");
}};

我会用:

public class Test {
    private static final Map MY_MAP = createMap();

    private static Map createMap() {
        Map result = new HashMap();
        result.put(1, "one");
        result.put(2, "two");
        return Collections.unmodifiableMap(result);
    }
}

它避免了匿名课程,我个人认为这是一种不好的风格,并避免

它使地图的创建更加明确

它使地图不可修改

因为MY_MAP是不变的,我会把它命名为常量

第二种方法的一个优点是你可以用它来包装,Collections.unmodifiableMap()以保证以后什么都不会更新集合:

private static final Map CONSTANT_MAP = 
    Collections.unmodifiableMap(new HashMap() {{ 
        put(1, "one");
        put(2, "two");
    }});

 // later on...

 CONSTANT_MAP.put(3, "three"); // going to throw an exception!

这是一个Java 8单行静态地图初始化器:

private static final Map 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在问题中初始化a ,你需要这样的东西:

static final Map MY_MAP = Arrays.stream(new Object[][]{
        {1, "one"},
        {2, "two"},
}).collect(Collectors.toMap(kv -> (Integer) kv[0], kv -> (String) kv[1]));

编辑(2):i_am_zero有一个更好的,具有混合类型功能的版本,它使用一组new SimpleEntry<>(k, v)调用.看看答案:https://stackoverflow.com/a/37384773/3950982

在Java 9中:

private static final Map MY_MAP = Map.of(1, "one", 2, "two");

有关详细信息,请参阅JEP 269.JDK 9 于2017年9月全面上市.

Java 9

我们可以Map.ofEntries用作:

import static java.util.Map.entry;
private static final Map 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.of按照Tagir的建议使用他的答案,但我们不能使用超过10个条目Map.of.

Java 8(整洁解决方案)

我们可以创建一个地图条目流.我们已经有两个实现Entry在java.util.AbstractMap它们SimpleEntry和SimpleImmutableEntry.对于这个例子,我们可以使用前者:

import java.util.AbstractMap.*;
private static final Map 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));

使用Eclipse 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 MAP =
        Maps.mutable.with(1, "one", 2, "two");

    private static final MutableMap MUTABLE_MAP =
       Maps.mutable.with(1, "one", 2, "two");


    private static final MutableMap UNMODIFIABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").asUnmodifiable();


    private static final MutableMap SYNCHRONIZED_MAP =
        Maps.mutable.with(1, "one", 2, "two").asSynchronized();


    private static final ImmutableMap IMMUTABLE_MAP =
        Maps.mutable.with(1, "one", 2, "two").toImmutable();


    private static final ImmutableMap IMMUTABLE_MAP2 =
        Maps.immutable.with(1, "one", 2, "two");
}

您还可以使用Eclipse Collections静态初始化原始映射.

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 MUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two");

    private static final MutableIntObjectMap UNMODIFIABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asUnmodifiable();

    private static final MutableIntObjectMap SYNCHRONIZED_INT_OBJ_MAP =
            IntObjectMaps.mutable.empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .asSynchronized();

    private static final ImmutableIntObjectMap IMMUTABLE_INT_OBJ_MAP =
            IntObjectMaps.mutable.empty()
                    .withKeyValue(1, "one")
                    .withKeyValue(2, "two")
                    .toImmutable();

    private static final ImmutableIntObjectMap IMMUTABLE_INT_OBJ_MAP2 =
            IntObjectMaps.immutable.empty()
                    .newWithKeyValue(1, "one")
                    .newWithKeyValue(2, "two");
} 

注意:我是Eclipse Collections的提交者

在这种情况下,我永远不会创建一个匿名子类.如果您想使地图不可修改,静态初始化程序也可以正常工作:

private static final Map MY_MAP;
static
{
    MaptempMap = new HashMap();
    tempMap.put(1, "one");
    tempMap.put(2, "two");
    MY_MAP = Collections.unmodifiableMap(tempMap);
}

也许有趣的是查看Google Collections,例如他们在页面上显示的视频.它们提供了各种方法来初始化地图和集合,并提供不可变的集合.

更新:此库现在名为Guava.

我喜欢匿名类,因为它很容易处理它:

public static final Map numbers = Collections.unmodifiableMap(new HashMap() {
    {
        put(1, "some value");
                    //rest of code here
    }
});

public class Test {
    private static final Map myMap;
    static {
        Map 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");
        }
    });
}

并且建议使用不可修改的Map作为常量,否则它不能被视为常量.

我强烈建议静态块样式的"双支撑初始化"样式.

有人可能会评论他们不喜欢匿名类,开销,性能等.

但我更考虑的是代码的可读性和可维护性.在这一点上,我站在一个双支撑是一个更好的代码风格而不是静态方法.

元素是嵌套和内联的.

这是更多的OO,而不是程序性的.

性能影响非常小,可以忽略不计.

更好的IDE大纲支持(而不是许多匿名静态{}阻止)

你保存了几行评论来为他们建立关系.

从异常和字节码优化器中防止未初始化对象的可能元素泄漏/实例引导.

不用担心静态块的执行顺序.

另外,你知道匿名类的GC,你总是可以使用它将它转换为普通的HashMap new HashMap(Map map).

你可以这样做,直到你遇到另一个问题.如果这样做,您应该使用完整的另一种编码风格(例如,没有静态,工厂类).

像往常一样apache-commons有正确的方法MapUtils.putAll(Map,Object []):

例如,要创建颜色映射:

Map colorMap = MapUtils.putAll(new HashMap(), new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}
 });

这是我最喜欢的,当我不想(或不能)使用番石榴ImmutableMap.of(),或者如果我需要一个可变的Map:

public static  Map asMap(Object... keysAndValues) {
    return new LinkedHashMap() {{
        for (int i = 0; i < keysAndValues.length - 1; i++) {
            put(keysAndValues[i].toString(), (A) keysAndValues[++i]);
        }
    }};
}

Map one = asMap("1stKey", "1stVal", "2ndKey", "2ndVal");
Map two = asMap("1stKey", Boolean.TRUE, "2ndKey", new Integer(2));

private static final Map myMap = new HashMap<>();
static {
    final Map 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 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);
}

public class Test {
    private static final Map 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 {
    private final Map m;

    public B(Map m) {
        this.m = m;
    }

    public B p(K k, V v) {
        m.put(k, v);
        return this; // Return this for chaining
    }
}

static final Map 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  HashMap unmodifiableMap(
            Class keyClazz,
            Class valClazz,
            Object...keyValues)
    {
        return Collections.unmodifiableMap(makeMap(
            keyClazz,
            valClazz,
            keyValues));
    }

    public static  HashMap makeMap(
            Class keyClazz,
            Class valClazz,
            Object...keyValues)
    {
        if (keyValues.length % 2 != 0)
        {
            throw new IllegalArgumentException(
                    "'keyValues' was formatted incorrectly!  "
                  + "(Expected an even length, but found '" + keyValues.length + "')");
        }

        HashMap result = new HashMap(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 cast(Class 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);
        }
    }
}