Inicializar HashMap en Java

1. Inicialice un HashMap usando la forma tradicional en Java
2. Inicialice un HashMap creando una subclase anónima en Java
3. Inicialice un HashMap con un solo par clave-valor usando Collections.singletonMap() en Java
4. Inicializar un HashMap usando Collectors.toMap() en Java 8
5. Inicialice un HashMap usando Map.of() en Java 9

HashMap es una forma muy conveniente de almacenar datos en un par clave-valor. Hay varias formas de inicializar un HashMap, y con cada actualización, Java hizo más fácil lograrlo.

Inicialice un HashMap usando la forma tradicional en Java

La forma más común y estándar de inicializar un HashMap se proporciona en el siguiente programa.

Declaramos un Map y ponemos los tipos de datos clave-valor como Cadena en el ejemplo. Inicializamos el HashMap usando new HashMap().

Este tipo de inicialización genera un tipo mutable de HasMap, e insertamos algunos datos en él usando el método put() donde el primer argumento es la clave. El segundo argumento es el valor.

En la última declaración, imprimimos todo el HashMap.

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

public class Main {
  public static void main(String[] args) {
    Map<String, String> hashMap = new HashMap<>();
    hashMap.put("key1", "String1");
    hashMap.put("key2", "String2");
    hashMap.put("key3", "String3");

    System.out.println(hashMap);
  }
}

Producción :

{key1=String1, key2=String2, key3=String3}

Inicialice un HashMap creando una subclase anónima en Java

Otra forma de inicializar un HashMap es usar llaves dobles y el método put() para insertar los datos.

Primero declaramos y luego inicializamos un HashMap con los datos del siguiente código. El mapExample es mutable, y podemos poner otro dato después de la inicialización.

No se recomienda esta forma de inicializar el mapa porque crea una nueva subclase con una clase anónima y una clase extra no es una forma muy eficiente de hacerlo.

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

public class Main {
  public static void main(String[] args) {
    Map<String, String> mapExample = new HashMap<>() {
      {
        put("Key01", "String01");
        put("Key02", "String02");
        put("Key03", "String03");
      }
    };

    mapExample.put("Key04", "String04");
    System.out.println(mapExample);
  }
}

Producción :

{Key01=String01, Key02=String02, Key03=String03, Key04=String04}

Inicialice un HashMap con un solo par clave-valor usando Collections.singletonMap() en Java

Esta es una forma de inicializar un HashMap insertando solo un solo par de datos clave-valor en él. Usamos el método estático singletonMap() de la clase Collections, que devuelve un mapa inmutable con una única entrada.

En el siguiente ejemplo, llamamos a la función Collections.singletonMap() y pasamos los datos clave-valor. El Map es inmutable, por lo que no podemos modificar ni insertar más datos después de la inicialización.

import java.util.Collections;
import java.util.Map;

public class Main {
  public static void main(String[] args) {
    Map<String, String> mapExample = Collections.singletonMap("key1", "value1");
    System.out.println(mapExample);
  }
}

Producción :

{key1=value1}

Inicializar un HashMap usando Collectors.toMap() en Java 8

En la actualización de Java 8, se introdujo Stream API, una secuencia de elementos que contienen métodos para realizar operaciones en varios tipos en Java, como Collections y Arrays.

El siguiente programa muestra el uso de Stream. Usamos la API Stream para llamar al método of() que devuelve secuencialmente un solo elemento en un Stream.

En el método of(), pasamos el tipo de objeto del elemento que queremos devolver. Especificamos new String[][], que es un array de tipo String, y luego en la matriz, insertamos los pares clave-valor.

Para convertir el flujo secuencial de elementos del array String en un Map, llamamos al método collect(), y en esta función llamamos a Collectors.toMap() que mapea los datos pasados ​​en un Map.

En el método Collectors.toMap() cogemos el primer elemento del array y lo ponemos como clave y el segundo como valor. Después de todo esto, el stream devuelve un único Map que almacenamos en mapExample.

import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    Map<String, String> mapExample =
        Stream.of(new String[][] {{"key1", "21"}, {"key2", "22"}, {"key3", "33"}})
            .collect(Collectors.toMap(
                collectorData -> collectorData[0], collectorData -> collectorData[1]));

    System.out.println(mapExample);
  }
}

Producción :

{key1=21, key2=22, key3=33}

Inicialice un HashMap usando Map.of() en Java 9

Otra forma de inicializar un HashMap es usar la función Map.of() de la versión Java 9. Map.of() mapea las claves y los valores pasados ​​como pares, y luego devuelve un HashMap inmutable.

Tenga en cuenta que Map.of() puede tomar un máximo de hasta diez entradas solamente.

import java.util.Map;

public class Main {
  public static void main(String[] args) {
    Map<String, String> mapExample = Map.of("key1", "Value1", "key2", "Value2", "key", "Value3");

    System.out.println(mapExample);
  }
}

Producción :

{key=Value3, key1=Value1, key2=Value2}