java - new - ¿Cómo inicializar directamente un HashMap(de manera literal)?

new hashmap java 8

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo puedo inicializar un mapa estático? 41 respuestas

¿Hay alguna manera de inicializar un HashMap de Java como este ?:

Map<String,String> test =
new HashMap<String, String>{"test":"test","test":"test"};

¿Cuál sería la sintaxis correcta? No he encontrado nada al respecto. es posible? Estoy buscando la forma más rápida y rápida de poner algunos valores "finales / estáticos" en un mapa que nunca cambian y se conocen de antemano al crear el Mapa.

Answer 1

Esta es una manera

HashMap<String, String> h = new HashMap<String, String>() {{
put("a","b");
}};

Sin embargo, debes tener cuidado y asegurarte de entender el código anterior (crea una nueva clase que hereda de HashMap). Por lo tanto, debe leer más aquí: http://www.c2.com/cgi/wiki?DoubleBraceInitialization , o simplemente usar Guava:

Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);

Answer 2

No hay una forma directa de hacerlo: Java no tiene literales de mapas (aún así, creo que se propusieron para Java 8).

A algunas personas les gusta esto:

Map<String,String> test = new HashMap<String, String>(){{
put("test","test"); put("test","test");}};

Esto crea una subclase anónima de HashMap, cuyo inicializador de instancia coloca estos valores. (Por cierto, un mapa no puede contener dos veces el mismo valor, su segunda posición sobrescribirá la primera. Usaré valores diferentes para los siguientes ejemplos).

La forma normal sería esta (para una variable local):

Map<String,String> test = new HashMap<String, String>();
test.put("test","test");
test.put("test1","test2");

Si su mapa de test es una variable de instancia, coloque la inicialización en un constructor o inicializador de instancia:

Map<String,String> test = new HashMap<String, String>();
{
test.put("test","test");
test.put("test1","test2");
}

Si su mapa de test es una variable de clase, ponga la inicialización en un inicializador estático:

static Map<String,String> test = new HashMap<String, String>();
static {
test.put("test","test");
test.put("test1","test2");
}

Si desea que su mapa nunca cambie, debe, después de la inicialización, ajustar su mapa con Collections.unmodifiableMap(...) . También puedes hacer esto en un inicializador estático:

static Map<String,String> test;
{
Map<String,String> temp = new HashMap<String, String>();
temp.put("test","test");
temp.put("test1","test2");
test = Collections.unmodifiableMap(temp);
}

(No estoy seguro de si ahora puede hacer la test final ... pruébelo e informe aquí).

Answer 3

No, tendrás que añadir todos los elementos manualmente. Puedes usar un inicializador estático aunque:

public class Demo
{
private static final Map<String, String> myMap;
static
{
myMap = new HashMap<String, String>();
myMap.put("a", "b");
myMap.put("c", "d");
}
}

Tenga en cuenta que usar una función para la inicialización hará lo mismo pero puede mejorar la legibilidad del código:

public class Demo
{
private static final Map<String, String> myMap = createMap();
private static Map<String, String> createMap()
{
Map<String,String> myMap = new HashMap<String,String>();
myMap.put("a", "b");
myMap.put("c", "d");
return myMap;
}
}

Java 9

En Java 9 se agregan un par de métodos de fábrica que también se pueden usar para simplificar la creación de mapas:

public class Demo {
private static final Map<String, String> test = Map.of("a", "b", "c", "d");
private static final Map<String, String> test2 = Map.ofEntries(
entry("a", "b"),
entry("c", "d")
);
}

En el ejemplo anterior, tanto test como test2 serán iguales, solo que con diferentes formas de expresar el Mapa. El método Map.of se define para un máximo de diez elementos en el mapa, mientras que el método Map.ofEntries no tendrá dicho límite.

Tenga en cuenta que en este caso el mapa resultante será un mapa inmutable. Si desea que el mapa sea mutable, puede copiarlo nuevamente, por ejemplo, usando mutableMap = new HashMap<>(Map.of("a", "b"));

(Ver también JEP 269 y el Javadoc )

Answer 4

Si permites librerías de terceros, puedes usar Guava de Guava para lograr una brevedad similar a la de un literal:

Map<String, String> test = ImmutableMap.of("k1", "v1", "k2", "v2");

Esto funciona para hasta 5 pares clave / valor , de lo contrario puede usar su builder :

Map<String, String> test = ImmutableMap.<String, String>builder()
.put("k1", "v1")
.put("k2", "v2")
...
.build();

• tenga en cuenta que la implementación de ImmutableMap de Guava difiere de la implementación de HashMap de Java (en particular, es inmutable y no permite claves / valores nulos)
• Para obtener más información, consulte el artículo de la guía del usuario de Guava sobre sus tipos de colección inmutables

Answer 5

Una alternativa, utilizando las clases y variables de Java 7: cree una clase HashMapBuilder con este método:

public static HashMap<String, String> build(String... data){
HashMap<String, String> result = new HashMap<String, String>();
if(data.length % 2 != 0)
throw new IllegalArgumentException("Odd number of arguments");
String key = null;
Integer step = -1;
for(String value : data){
step++;
switch(step % 2){
case 0:
if(value == null)
throw new IllegalArgumentException("Null key value");
key = value;
continue;
case 1:
result.put(key, value);
break;
}
}
return result;
}

Utilice el método de esta manera:

HashMap<String,String> data = HashMapBuilder.build("key1","value1","key2","value2");

Answer 6

Map<String,String> test = new HashMap<String, String>()
{
{
put(key1, value1);
put(key2, value2);
}
};