Initialiser HashMap en Java

1. Initialiser un HashMap à l’aide de la méthode traditionnelle en Java
2. Initialiser un HashMap en créant une sous-classe anonyme en Java
3. Initialiser un HashMap avec une seule paire clé-valeur à l’aide de Collections.singletonMap() en Java
4. Initialiser un HashMap à l’aide de Collectors.toMap() dans Java 8
5. Initialiser un HashMap à l’aide de Map.of() dans Java 9

HashMap est un moyen très pratique de stocker des données dans une paire clé-valeur. Il existe plusieurs façons d’initialiser un HashMap, et à chaque mise à jour, Java a facilité sa réalisation.

Initialiser un HashMap à l’aide de la méthode traditionnelle en Java

La manière la plus courante et la plus standard d’initialiser un HashMap est donnée dans le programme ci-dessous.

Nous déclarons une Map et mettons les types de données clé-valeur comme String dans l’exemple. Nous initialisons le HashMap à l’aide de new HashMap().

Ce type d’initialisation génère un type mutable de HasMap, et nous y insérons des données en utilisant la méthode put() où le premier argument est la key. Le deuxième argument est la value.

Dans la dernière instruction, nous imprimons l’ensemble du 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);
  }
}

Production :

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

Initialiser un HashMap en créant une sous-classe anonyme en Java

Une autre façon d’initialiser un HashMap est d’utiliser des doubles accolades et la méthode put() pour insérer les données.

Nous déclarons d’abord puis initialisons un HashMap avec les données dans le code suivant. Le mapExample est mutable, et on peut mettre une autre donnée après l’initialisation.

Cette façon d’initialiser la carte n’est pas recommandée car elle crée une nouvelle sous-classe avec une classe anonyme et une classe supplémentaire n’est pas une manière très efficace de le faire.

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);
  }
}

Production :

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

Initialiser un HashMap avec une seule paire clé-valeur à l’aide de Collections.singletonMap() en Java

C’est un moyen d’initialiser un HashMap en n’y insérant qu’une seule paire de données clé-valeur. Nous utilisons la méthode statique singletonMap() de la classe Collections, qui renvoie une carte immuable avec une seule entrée.

Dans l’exemple ci-dessous, nous appelons la fonction Collections.singletonMap() et transmettons les données clé-valeur. La Map est immuable, nous ne pouvons donc pas modifier ou insérer plus de données après l’initialisation.

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);
  }
}

Production :

{key1=value1}

Initialiser un HashMap à l’aide de Collectors.toMap() dans Java 8

Dans la mise à jour Java 8, l’API Stream a été introduite, une séquence d’éléments contenant des méthodes pour effectuer des opérations sur différents types en Java, comme les collections et les tableaux.

Le programme ci-dessous montre l’utilisation de Stream. Nous utilisons l’API Stream pour appeler la méthode of() qui renvoie séquentiellement un seul élément dans un Stream.

Dans la méthode of(), on passe le type d’objet de l’élément que l’on veut retourner. On précise new String[][], qui est un tableau de type String, puis dans le tableau, on insère les paires clé-valeur.

Pour convertir le flux séquentiel des éléments du tableau String en un Map, nous appelons la méthode collect(), et dans cette fonction, nous appelons Collectors.toMap() qui mappe les données transmises dans un Map.

Dans la méthode Collectors.toMap(), nous prenons le premier élément du tableau et le mettons comme clé et le second comme valeur. Après tout cela, le stream renvoie un seul Map que nous stockons dans 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);
  }
}

Production :

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

Initialiser un HashMap à l’aide de Map.of() dans Java 9

Une autre façon d’initialiser un HashMap est d’utiliser la fonction Map.of() de la version Java 9. Map.of() mappe les clés et les valeurs passées par paires, puis renvoie un HashMap immuable.

Notez que Map.of() ne peut prendre qu’un maximum de dix entrées.

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);
  }
}

Production :

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