有没有用Java编写地图文字样式的最佳实践？

简而言之，如果你想用Java编写一个常量映射，比如Python和Javascript，你可以用文字来编写

T<String,String> CONSTANTS =
{
    "CONSTANT_NAME_0": CONSTANT_VALUE_0 ,
    "CONSTANT_NAME_1": CONSTANT_VALUE_1 ,
    "CONSTANT_NAME_2": CONSTANT_VALUE_2 ,
    //...
} ;

T常数=
{
“常量名称”：常量值，
“常量名称”：常量值，
“常数\名称\ 2”：常数\值\ 2，
//...
} ;

---

是否有一个

类

或任何预设的

对象

，可以用来编写这样的数据结构？

不，Java没有映射文字。最接近这一点的是使用Google Collections：

Map CONSTANTS=ImmutableMap.of(
名称_1，值_1，
名称2，值2
//等等。
);

这里有另一种方法，最适合于不会改变的地图：

public class Whatever {
    private static Map<String,String> map = new HashMap<String,String>();

    static {
        map.put("A", "Apple");
        map.put("B", "Banana");
        // etc
    }
}

公共类{
private static Map=new HashMap（）；
静止的{
放在地图上（“A”，“苹果”）；
地图。把（“B”、“香蕉”）；
//等
}
}

Java7假设实现以下语法：

Map<String, String> = {
    "key1": "value",
    "key2": "value",
    "key3": "value",
    "key4": "value"
};

Map={
“键1”：“值”，
“键2”：“值”，
“键3”：“值”，
“键4”：“值”
};

然而，现在你不得不使用乔恩或托尼·恩尼斯提出的解决方案。

常数？我会用一个

例如，

NAME_2

的值可通过以下方式获得：

String name2value = Constants.NAME_2.value();

---

只给枚举一个更合理的名称，例如

设置

，

默认值

，等等，不管这些名称/值对实际代表什么。

好的，随着Jorn的改进，我似乎根本无法更改映射，无论是内部还是外部。也许不太可读，但如果你需要地图是不可修改的，我认为这是更好的

public class MapTest {
    private static Map<String, String> map = initMap();

    private static Map<String, String> initMap() {
        Map<String, String> map = new HashMap<String, String>();

        map.put("A", "Apple");
        map.put("B", "Banana");
        // etc
        return Collections.unmodifiableMap(map);
    }

    public Map<String, String> getMap() {
        return map;
    }

    public static void main(String[] args) {
        MapTest m = new MapTest();
        System.out.println(m.getMap().get("A"));
        m.getMap().put("this", "that");
    }
}

公共类映射测试{
私有静态映射Map=initMap（）；
私有静态映射initMap（）{
Map Map=newhashmap（）；
放在地图上（“A”，“苹果”）；
地图。把（“B”、“香蕉”）；
//等
返回集合。不可修改映射（map）；
}
公共地图getMap（）{
返回图；
}
公共静态void main（字符串[]args）{
MapTest m=新的MapTest（）；
System.out.println（m.getMap（）.get（“A”）；
m、 getMap（）.put（“这个”、“那个”）；
}
}

对不起，我是个修补匠：-）这里有一个更干净的方法

public class MapTest {
    private static Map<String, String> map;

    static {
        Map<String, String> tmpMap = new HashMap<String, String>();

        tmpMap.put("A", "Apple");
        tmpMap.put("B", "Banana");
        // etc
        map = Collections.unmodifiableMap(tmpMap);
    }

    public Map<String, String> getMap() {
        return map;
    }
}

公共类映射测试{
私有静态地图；
静止的{
Map tmpMap=newhashmap（）；
tmpMap.put（“A”、“苹果”）；
tmpMap.put（“B”、“香蕉”）；
//等
map=Collections.unmodifiableMap（tmpMap）；
}
公共地图getMap（）{
返回图；
}
}

您可以自己编写一个快速助手函数：

@SuppressWarnings("unchecked")
public static <K,V> Map<K,V> ImmutableMap(Object... keyValPair){
    Map<K,V> map = new HashMap<K,V>();

    if(keyValPair.length % 2 != 0){
        throw new IllegalArgumentException("Keys and values must be pairs.");
    }

    for(int i = 0; i < keyValPair.length; i += 2){
        map.put((K) keyValPair[i], (V) keyValPair[i+1]);
    }

    return Collections.unmodifiableMap(map);
}

---

我喜欢这样做：

Map map = new HashMap() {{
    put("foo", "bar");
    put(123, 456);
}};

---

双{{}是一个实例初始化块。它们有点不寻常，但很有用。不需要库或助手。

我喜欢在同一行上进行声明和初始化。我已经使用这个方便的小实用程序很长时间了，它基本上是我的“映射文字”，直到它们在语言中“正确”完成，我将继续这样使用：）

很高兴在这里分享

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A handy utility for creating and initializing Maps in a single statement.
 * @author Jonathan Cobb. This source code is in the Public Domain.
 */
public class MapBuilder {

    /**
     * Most common create/init case. Usage:
     *
     *   Map<String, Boolean> myPremadeMap = MapBuilder.build(new Object[][]{
     *     { "a", true }, { "b", false }, { "c", true }, { "d", true },
     *     { "e", "yes, still dangerous but at least it's not an anonymous class" }
     *   });
     *
     * If your keys and values are of the same type, it will even be typesafe:
     *   Map<String, String> someProperties = MapBuilder.build(new String[][]{
     *       {"propA", "valueA" }, { "propB", "valueB" }
     *   });
     *
     * @param values [x][2] array. items at [x][0] are keys and [x][1] are values.
     * @return a LinkedHashMap (to preserve order of declaration) with the "values" mappings
     */
    public static <K,V> Map<K,V> build(Object[][] values) {
        return build(new LinkedHashMap<K,V>(), values);
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(new MyMapClass(options),
     *                                    new Object[][]{ {k,v}, {k,v}, ... });
     * @param map add key/value pairs to this map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Map<K,V> map, Object[][] values) {
        for (Object[] value : values) {
            map.put((K) value[0], (V) value[1]);
        }
        return map;
    }

    /** Same as above, for single-value maps */
    public static <K,V> Map<K,V> build(Map<K,V> map, K key, V value) {
        return build(map, new Object[][]{{key,value}});
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(MyMapClass.class, new Object[][]{ {k,v}, {k,v}, ... });
     * @param mapClass a Class that implements Map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Class<? extends Map<K,V>> mapClass, Object[][] values) {

        final Map<K,V> map;
        try { map = mapClass.newInstance(); } catch (Exception e) {
            throw new IllegalStateException("Couldn't create new instance of class: "+mapClass.getName(), e);
        }
        return build(map, values);
    }

    /** Usage: Map<K,V> myMap = MapBuilder.build(key, value); */
    public static <K,V> Map build(K key, V value) {
        Map<K,V> map = new HashMap<>();
        map.put(key, value);
        return map;
    }

}

import java.util.HashMap；
导入java.util.LinkedHashMap；
导入java.util.Map；
/**
*一个方便的实用工具，用于在一条语句中创建和初始化映射。
*@作者乔纳森·科布。此源代码位于公共域中。
*/
公共类映射生成器{
/**
*最常见的create/init案例。用法：
*
*Map mypredemap=MapBuilder.build（新对象[][]{
*{“a”，真}，{“b”，假}，{“c”，真}，{“d”，真}，
*{“e”，“是的，仍然很危险，但至少它不是匿名类”}
*   });
*
*如果您的键和值属于同一类型，它甚至是类型安全的：
*Map someProperties=MapBuilder.build（新字符串[][]{
*{“propA”，“valueA”}，{“propB”，“valueB”}
*   });
*
*@param values[x][2]数组，[x][0]处的项为键，[x][1]处的项为值。
*@返回带有“值”映射的LinkedHashMap（以保留声明顺序）
*/
公共静态映射生成（对象[][]值）{
返回生成（新LinkedHashMap（），值）；
}
/**
*用法：
*Map myMap=MapBuilder.build（新的MyMapClass（选项），
*新对象[][{{k，v}，{k，v}，…}）；
*@param map将键/值对添加到此映射
*@return传入的映射，现在包含新的“值”映射
*/
公共静态映射生成（映射映射，对象[][]值）{
for（对象[]值：值）{
map.put（（K）值[0]，（V）值[1]）；
}
返回图；
}
/**同上，对于单值映射*/
公共静态映射构建（映射映射，K键，V值）{
返回构建（映射，新对象[][{{key，value}}）；
}
/**
*用法：
*Map myMap=MapBuilder.build（MyMapClass.class，新对象[][{{k，v}，{k，v}，…}）；
*@param mapClass实现映射的类
*@return传入的映射，现在包含新的“值”映射
*/
公共静态映射构建（ClassI没有说有。我会研究一下。谢谢。-1因为这使用了一个外部库，并且不比xpmatteo的答案短。这也不是最接近您的答案（答案表明没有不依赖外部库的替代方案）@Stijn我认为Guava应该始终在您的类路径上。至于编写maps文字样式，Java核心库中没有其他选择。在我看来，xpmatteo的答案不符合文字样式。必须创建一个子类（这就是双括号初始化的真正功能）我认为主要的问题是“of”函数只接受最大的5个键值对？是的，但不是真正的问题：有
ImmutableMap.builder（）
这允许您创建更大的不可变映射。这并不能确保您的映射不能更改。您最好在静态块中创建映射，
Map<String,Double> constants = ImmutableMap(
    "CONST_0", 1.0,
    "CONST_1", 2.0
);

Map map = new HashMap() {{
    put("foo", "bar");
    put(123, 456);
}};

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * A handy utility for creating and initializing Maps in a single statement.
 * @author Jonathan Cobb. This source code is in the Public Domain.
 */
public class MapBuilder {

    /**
     * Most common create/init case. Usage:
     *
     *   Map<String, Boolean> myPremadeMap = MapBuilder.build(new Object[][]{
     *     { "a", true }, { "b", false }, { "c", true }, { "d", true },
     *     { "e", "yes, still dangerous but at least it's not an anonymous class" }
     *   });
     *
     * If your keys and values are of the same type, it will even be typesafe:
     *   Map<String, String> someProperties = MapBuilder.build(new String[][]{
     *       {"propA", "valueA" }, { "propB", "valueB" }
     *   });
     *
     * @param values [x][2] array. items at [x][0] are keys and [x][1] are values.
     * @return a LinkedHashMap (to preserve order of declaration) with the "values" mappings
     */
    public static <K,V> Map<K,V> build(Object[][] values) {
        return build(new LinkedHashMap<K,V>(), values);
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(new MyMapClass(options),
     *                                    new Object[][]{ {k,v}, {k,v}, ... });
     * @param map add key/value pairs to this map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Map<K,V> map, Object[][] values) {
        for (Object[] value : values) {
            map.put((K) value[0], (V) value[1]);
        }
        return map;
    }

    /** Same as above, for single-value maps */
    public static <K,V> Map<K,V> build(Map<K,V> map, K key, V value) {
        return build(map, new Object[][]{{key,value}});
    }

    /**
     * Usage:
     *  Map<K,V> myMap = MapBuilder.build(MyMapClass.class, new Object[][]{ {k,v}, {k,v}, ... });
     * @param mapClass a Class that implements Map
     * @return the map passed in, now containing new "values" mappings
     */
    public static <K,V> Map<K,V> build(Class<? extends Map<K,V>> mapClass, Object[][] values) {

        final Map<K,V> map;
        try { map = mapClass.newInstance(); } catch (Exception e) {
            throw new IllegalStateException("Couldn't create new instance of class: "+mapClass.getName(), e);
        }
        return build(map, values);
    }

    /** Usage: Map<K,V> myMap = MapBuilder.build(key, value); */
    public static <K,V> Map build(K key, V value) {
        Map<K,V> map = new HashMap<>();
        map.put(key, value);
        return map;
    }

}