Короче говоря, если вы хотите написать карту, например. константы в 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 ,
//...
} ;
есть ли Class или любой пресет Object, который вы можете использовать для записи такой структуры данных?
Константы? Я бы использовал enum.
public enum Constants {
NAME_1("Value1"),
NAME_2("Value2"),
NAME_3("Value3");
private String value;
Constants(String value) {
this.value = value;
}
public String value() {
return value;
}
}
Значение, например. NAME_2 можно получить следующим образом:
String name2value = Constants.NAME_2.value();
Дайте перечислению только более разумное имя, например. Settings, Defaults и т.д., независимо от того, что фактически представляют собой пары имя/значение.
Мне нравится делать это следующим образом:
Map map = new HashMap() {{
put("foo", "bar");
put(123, 456);
}};
Двойной {{}} является блоком инициализации экземпляра. Они немного необычны, но они полезны. Нет необходимости в библиотеках или помощниках.
Нет, Java не имеет буквенного отображения. Самое близкое, что вы придете к этому, - это Google Collections ImmutableMap:
Map<K,V> CONSTANTS = ImmutableMap.of(
NAME_1, VALUE_1,
NAME_2, VALUE_2
//etc.
);
Извините, я возик:-) Вот несколько более чистый способ.
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;
}
}
Вы можете написать себе быструю вспомогательную функцию:
@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);
}
Обратите внимание, что приведенный выше код не остановит вас от перезаписи констант с тем же именем, используя CONST_1 несколько мест в вашем списке приведет к появлению окончательного значения CONST_1.
Использование - это что-то вроде:
Map<String,Double> constants = ImmutableMap(
"CONST_0", 1.0,
"CONST_1", 2.0
);
Здесь другой способ, наиболее подходящий для карт, которые не будут меняться:
public class Whatever {
private static Map<String,String> map = new HashMap<String,String>();
static {
map.put("A", "Apple");
map.put("B", "Banana");
// etc
}
}
Java7 предполагает реализовать следующий синтаксис:
Map<String, String> = {
"key1": "value",
"key2": "value",
"key3": "value",
"key4": "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");
}
}
Мне нравится делать объявление и инициализацию в одной строке. Я использовал эту удобную небольшую утилиту так долго, что в основном есть мой "буквенный символ", и пока они не закончатся в языке, я продолжу использовать его так: )
С удовольствием поделимся им здесь.
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 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;
}
}