我更喜欢使用静态初始化式来避免生成匿名类(这将没有进一步的用途)，因此我将列出使用静态初始化式进行初始化的技巧。所有列出的解决方案/提示都是类型安全的。

注意:这个问题没有说任何关于使地图不可修改的问题，所以我将把它省略，但要知道可以很容易地使用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");
}

第二个提示

第二个技巧是，您可以创建一个helper方法来添加条目;你也可以将这个helper方法设为public，如果你想:

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添加元素。为了使它可重用，我们可以使映射本身成为helper方法的参数，但这样初始化代码就不会更短了。

第三个技巧

第三个技巧是，您可以创建一个具有填充功能的可重用的类似生成器的helper类。这是一个简单的，10行类型安全的helper类:

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

第二个方法的一个优点是，你可以用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!

第二种方法(双括号初始化)被认为是一种反模式，因此我将采用第一种方法。

另一个初始化静态Map的简单方法是使用这个实用函数:

public static <K, V> Map<K, V> mapOf(Object... keyValues) {
    Map<K, V> map = new HashMap<>(keyValues.length / 2);

    for (int index = 0; index < keyValues.length / 2; index++) {
        map.put((K)keyValues[index * 2], (V)keyValues[index * 2 + 1]);
    }

    return map;
}

Map<Integer, String> map1 = mapOf(1, "value1", 2, "value2");
Map<String, String> map2 = mapOf("key1", "value1", "key2", "value2");

注意:在Java 9中你可以使用Map.of

我喜欢用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用户指南中的不可变集合解释。

(一个子集)Guava过去被称为谷歌集合。如果您还没有在Java项目中使用这个库，我强烈建议您尝试一下!正如其他SO用户所认同的那样，Guava已经迅速成为Java最流行和最有用的免费第三方库之一。(如果你是新手，在这个链接后面有一些很好的学习资源。)

更新(2015):至于Java 8，嗯，我仍然会使用Guava方法，因为它比其他任何方法都要干净得多。如果不希望依赖于Guava，可以考虑使用普通的init方法。如果你问我，使用二维数组和流API的黑客是非常丑陋的，如果你需要创建一个键和值不相同类型的Map(如Map<Integer, String>在问题中)，就会变得更加丑陋。

至于Guava的未来，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> 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");
        }
    });
}

并且建议对常量使用unmodifiableMap，否则它不能被视为常量。