Как я могу инициализировать статическую карту?
Как бы вы инициализировали статический Map на яве?
Способ первый: статический инициализатор
Способ второй: инициализатор экземпляра (анонимный подкласс) или какой-то другой метод?
Каковы плюсы и минусы каждого?
Вот пример, иллюстрирующий два метода:
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");
}
};
}
41 ответ
Инициализатор экземпляра - это просто синтаксический сахар в этом случае, верно? Я не понимаю, зачем вам нужен дополнительный анонимный класс только для инициализации. И это не сработает, если создаваемый класс является окончательным.
Вы также можете создать неизменяемую карту, используя статический инициализатор:
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);
}
}
Мне нравится гуавский способ инициализации статической неизменной карты:
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.
(Подмножество) Гуава раньше назывался Google Collections. Если вы еще не используете эту библиотеку в своем проекте Java, я настоятельно рекомендую попробовать! Guava быстро стал одним из самых популярных и полезных бесплатных сторонних библиотек для Java, как соглашаются другие пользователи SO. (Если вы новичок в этом, за этой ссылкой есть несколько отличных учебных ресурсов.)
Обновление (2015): Что касается Java 8, я бы по-прежнему использовал подход Guava, потому что он намного чище, чем все остальное. Если вам не нужна зависимость от Guava, рассмотрите простой старый метод init. Хак с двумерным массивом и Stream API довольно уродлив, если вы спросите меня, и становится уродливее, если вам нужно создать карту, ключи и значения которой не одного типа (например, Map<Integer, String> в вопросе).
Что касается будущего Guava в целом, что касается Java 8, Луи Вассерман сказал об этом еще в 2014 году, а [ обновление ] в 2016 году было объявлено, что Guava 21 будет требовать и должным образом поддерживать Java 8.
Обновление (2016): Как отмечает Тагир Валеев, 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]));
Редактирование (2): есть лучшая версия с поддержкой смешанного типа от i_am_zero, которая использует поток new SimpleEntry<>(k, v) звонки. Проверьте этот ответ: /questions/2599102/kak-ya-mogu-initsializirovat-staticheskuyu-kartu/2599105#2599105
Java 8 (аккуратное решение)
Мы можем создать поток записей на карте. У нас уже есть две реализации Entry в java.util.AbstractMap которые являются SimpleEntry и SimpleImmutableEntry. Для этого примера мы можем использовать первый как:
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 мы также можем использовать Map.of как предположил Тагир в своем ответе здесь.
С 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 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<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
Я бы никогда не создал анонимный подкласс в этой ситуации. Статические инициализаторы работают одинаково хорошо, если вы хотите сделать карту не изменяемой, например:
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);
}
Мне нравится анонимный класс, потому что с ним легко иметь дело:
public static final Map<?, ?> numbers = Collections.unmodifiableMap(new HashMap<Integer, String>() {
{
put(1, "some value");
//rest of code here
}
});
Может быть, интересно проверить Коллекции Google, например, видео, которые они имеют на своей странице. Они предоставляют различные способы инициализации карт и наборов, а также предоставляют неизменные коллекции.
Обновление: эта библиотека теперь называется Guava.
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 для констант, иначе он не может рассматриваться как константа.
Я мог бы настоятельно рекомендовать стиль "инициализация двойной скобкой" вместо стиля статического блока.
Кто-то может прокомментировать, что ему не нравятся анонимный класс, накладные расходы, производительность и т. Д.
Но то, что я больше рассматриваю, - это удобочитаемость кода и удобство обслуживания. С этой точки зрения, я считаю, что двойная скобка - лучший стиль кода, а не статический метод.
- Элементы являются вложенными и встроенными.
- Это больше ОО, а не процедурный.
- влияние на производительность действительно мало и может быть проигнорировано.
- Лучшая поддержка структуры IDE (а не много анонимных статических {} блоков)
- Вы сохранили несколько строк комментариев, чтобы привести их отношения.
- Предотвращение возможной утечки элементов / экземпляра неинициализированного объекта из исключения и оптимизатора байт-кода.
- Не беспокойтесь о порядке выполнения статического блока.
Кроме того, если вы знаете GC анонимного класса, вы всегда можете преобразовать его в обычный HashMap, используя new HashMap(Map map),
Вы можете делать это, пока не столкнетесь с другой проблемой. Если вы это сделаете, вы должны использовать для этого другой стиль кодирования (например, без статического, заводского класса).
Как обычно, apache-commons имеет правильный метод MapUtils.putAll (Map, Object []):
Например, чтобы создать цветную карту:
Map<String, String> colorMap = MapUtils.putAll(new HashMap<String, String>(), new String[][] {
{"RED", "#FF0000"},
{"GREEN", "#00FF00"},
{"BLUE", "#0000FF"}
});
Вот мой любимый, когда я не хочу (или не могу) использовать гуавы 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));
Я предпочитаю использовать статический инициализатор, чтобы избежать генерации анонимных классов (что не имело бы никакой дальнейшей цели), поэтому я перечислю советы по инициализации со статическим инициализатором. Все перечисленные решения / советы являются типобезопасными.
Примечание: в этом вопросе ничего не говорится о том, чтобы сделать карту не изменяемой, поэтому я это опущу, но знаю, что это легко сделать с помощью 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);
}
Вспомогательный метод здесь не может использоваться повторно, потому что он может только добавлять элементы в myMap2, Чтобы сделать его многократно используемым, мы могли бы сделать саму карту параметром вспомогательного метода, но тогда код инициализации не будет короче.
Третий совет
Третий совет заключается в том, что вы можете создать многократно используемый вспомогательный класс, похожий на конструктор, с заполненной функциональностью. Это действительно простой 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
}
}
Если вы хотите неизменяемую карту, то, наконец, в java 9 добавлен классный заводской метод. of в Map интерфейс. Аналогичный метод добавлен в Set, List, а также.
Map<String, String> unmodifiableMap = Map.of("key1", "value1", "key2", "value2");
Если вам нужно что-то лаконичное и относительно безопасное, вы можете просто перенести проверку типов во время компиляции на время выполнения:
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);
}
}
}
Создаваемый вами анонимный класс хорошо работает. Однако вы должны знать, что это внутренний класс, и поэтому он будет содержать ссылку на экземпляр окружающего класса. Таким образом, вы обнаружите, что не можете делать с ним определенные вещи (используя XStream для одного). Вы получите очень странные ошибки.
Сказав это, до тех пор, пока вы знаете, тогда этот подход хорош. Я использую его большую часть времени для краткой инициализации всех видов коллекций.
РЕДАКТИРОВАТЬ: правильно отметил в комментариях, что это статический класс. Очевидно, я не читал это достаточно внимательно. Однако мои комментарии все еще применимы к анонимным внутренним классам.
Ваш второй подход (инициализация двойной скобки) считается анти-паттерном, поэтому я бы остановился на первом подходе.
Другой простой способ инициализации статической карты - использование этой служебной функции:
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
Вы можете использовать StickyMap а также MapEntry от Cactoos:
private static final Map<String, String> MAP = new StickyMap<>(
new MapEntry<>("name", "Jeffrey"),
new MapEntry<>("age", "35")
);
В 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 - он безопасен и легко приспосабливается к различным типам ключей и значений.
Если вам нужно добавить только одно значение на карту, вы можете использовать Collections.singletonMap:
Map<K, V> map = Collections.singletonMap(key, value)
Поскольку 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}
Это намного удобнее, чем создавать и заполнять карту элементом одновременно.
Я не видел подход, который я использую (и который мне нравится), размещенный в каких-либо ответах, так что вот оно:
Мне не нравится использовать статические инициализаторы, потому что они неуклюжи, и мне не нравятся анонимные классы, потому что они создают новый класс для каждого экземпляра.
вместо этого я предпочитаю инициализацию, которая выглядит так:
map(
entry("keyA", "val1"),
entry("keyB", "val2"),
entry("keyC", "val3")
);
К сожалению, эти методы не являются частью стандартной библиотеки Java, поэтому вам нужно будет создать (или использовать) служебную библиотеку, которая определяет следующие методы:
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)
(вы можете использовать "import static", чтобы избежать добавления префикса имени метода)
Я нашел полезным предоставить аналогичные статические методы для других коллекций (list, set, sortedSet, sortedMap и т. Д.)
Это не так хорошо, как инициализация объекта json, но это шаг в этом направлении, что касается читабельности.
Мне не нравится синтаксис статического инициализатора, и я не убежден в анонимных подклассах. В общем, я согласен со всеми минусами использования статических инициализаторов и со всеми минусами использования анонимных подклассов, которые были упомянуты в предыдущих ответах. С другой стороны, плюсов, представленных в этих постах, мне недостаточно. Я предпочитаю использовать статический метод инициализации:
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;
}
}
JEP 269 предоставляет некоторые удобные фабричные методы для API коллекций. Методы этой фабрики отсутствуют в текущей версии Java, которая составляет 8, но запланированы для выпуска Java 9.
За Map Есть два заводских метода: of а также ofEntries, С помощью of, вы можете передать чередующиеся пары ключ / значение. Например, чтобы создать Map лайк {age: 27, major: cs}:
Map<String, Object> info = Map.of("age", 27, "major", "cs");
В настоящее время существует десять перегруженных версий для of, так что вы можете создать карту, содержащую десять пар ключ / значение. Если вам не нравится это ограничение или переменный ключ / значения, вы можете использовать ofEntries:
Map<String, Object> info = Map.ofEntries(
Map.entry("age", 27),
Map.entry("major", "cs")
);
И то и другое of а также ofEntries вернет неизменный Map, так что вы не можете изменить их элементы после строительства. Вы можете опробовать эти функции, используя JDK 9 Ранний доступ.
Я прочитал ответы и решил написать свой собственный конструктор карт. Не стесняйтесь копировать-вставить и наслаждаться.
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* A tool for easy creation of a map. Code example:<br/>
* {@code MapBuilder.of("name", "Forrest").and("surname", "Gump").build()}
* @param <K> key type (inferred by constructor)
* @param <V> value type (inferred by constructor)
* @author Vlasec (for http://stackru.com/a/30345279/1977151)
*/
public class MapBuilder <K, V> {
private Map<K, V> map = new HashMap<>();
/** Constructor that also enters the first entry. */
private MapBuilder(K key, V value) {
and(key, value);
}
/** Factory method that creates the builder and enters the first entry. */
public static <A, B> MapBuilder<A, B> of(A key, B value) {
return new MapBuilder<>(key, value);
}
/** Puts the key-value pair to the map and returns itself for method chaining */
public MapBuilder<K, V> and(K key, V value) {
map.put(key, value);
return this;
}
/**
* If no reference to builder is kept and both the key and value types are immutable,
* the resulting map is immutable.
* @return contents of MapBuilder as an unmodifiable map.
*/
public Map<K, V> build() {
return Collections.unmodifiableMap(map);
}
}
РЕДАКТИРОВАТЬ: В последнее время я продолжаю находить публичный статический метод of довольно часто, и мне это нравится. Я добавил его в код и сделал конструктор приватным, переключившись на статический шаблон метода фабрики.
Ну... я люблю перечисления;)
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 ) );
}