Initialiser un HashMap en Java

1. Vue d'ensemble

Dans ce didacticiel, nous allons découvrir différentes manières d'initialiser un JavaHashMap in.

Nous utiliserons Java 8 ainsi que Java 9.

Lectures complémentaires:

Comparer deux HashMaps en Java

Apprenez à comparer deux HashMaps en Java et à trouver les différences entre eux.

Travailler avec des cartes en utilisant des flux

Apprendre à combiner Java Maps et Streams

2. L'initialiseur statique pour unHashMap statique

On peut initialiser unHashMap en utilisant un bloc de codestatic:

public static Map articleMapOne;
static {
    articleMapOne = new HashMap<>();
    articleMapOne.put("ar01", "Intro to Map");
    articleMapOne.put("ar02", "Some article");
}

L'avantage de ce type d'initialisation est que la carte est modifiable mais qu'elle ne fonctionnera que pour les statiques. Les inscriptions peuvent être ajoutées et supprimées au besoin.

Allons-y et testons-le:

@Test
public void givenStaticMap_whenUpdated_thenCorrect() {

    MapInitializer.articleMapOne.put(
      "NewArticle1", "Convert array to List");

    assertEquals(
      MapInitializer.articleMapOne.get("NewArticle1"),
      "Convert array to List");
}

Nous pouvons également initialiser la carte en utilisant la syntaxe à double accolade:

Map doubleBraceMap  = new HashMap() {{
    put("key1", "value1");
    put("key2", "value2");
}};

Notez que,we must try to avoid this initialization technique as it creates an anonymous extra class at every usage, and also holds hidden references to the enclosing object et peut provoquer des problèmes de fuite de mémoire.

3. Utiliser les collections Java

Si nous avons besoin de créer une carte singleton, immuable, avec une seule entrée,Collections.singletonMap() devient très utile:

public static Map createSingletonMap() {
    return Collections.singletonMap("username1", "password1");
}

Notez que la carte ici est immuable, si nous essayons d'ajouter plus d'entrées, elle lancerajava.lang.UnsupportedOperationException.

Nous pouvons également créer une carte vide immuable en utilisantCollections.emptyMap():

Map emptyMap = Collections.emptyMap();

4. Le Java 8 Way

Ici, dans cette section, examinons les moyens d'initialiser une carte à l'aide de Java 8Stream API.

4.1. Utilisation deCollectors.toMap()

Utilisons unStream d'un tableauString bidimensionnel et rassemblons-les dans une carte:

Map map = Stream.of(new String[][] {
  { "Hello", "World" },
  { "John", "Doe" },
}).collect(Collectors.toMap(data -> data[0], data -> data[1]));

Remarquez ici que le type de données de la clé et la valeur duMap sont identiques.

Afin de le rendre plus générique, prenons le tableau deObjects and pour effectuer la même opération:

 Map map = Stream.of(new Object[][] {
     { "data1", 1 },
     { "data2", 2 },
 }).collect(Collectors.toMap(data -> (String) data[0], data -> (Integer) data[1]));

Ici, nous créons une carte de la clé enString et de la valeur enInteger.

4.2. Utilisation d'un flux deMap.Entry

Ici, nous allons utiliser les instances deMap.Entry. C'est une autre approche où nous avons différents types de clés et de valeurs.

Commençons par utiliserSimpleEntry implementation de l’interfaceEntry :

Map map = Stream.of(
  new AbstractMap.SimpleEntry<>("idea", 1),
  new AbstractMap.SimpleEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Maintenant, créons la carte en utilisantSimpleImmutableEntry implementation:

Map map = Stream.of(
  new AbstractMap.SimpleImmutableEntry<>("idea", 1),
  new AbstractMap.SimpleImmutableEntry<>("mobile", 2))
  .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

4.3. Initialiser une carte immuable

Dans certains cas d'utilisation, nous devons initialiser une carte immuable. Cela pourrait être fait en enveloppant lesCollectors.toMap() dansCollectors.collectingAndThen():

Map map = Stream.of(new String[][] {
    { "Hello", "World" },
    { "John", "Doe" },
}).collect(Collectors.collectingAndThen(
    Collectors.toMap(data -> data[0], data -> data[1]),
    Collections:: unmodifiableMap));

Notez que nous devrions éviter d'utiliser une telle initialisation en utilisantStreams, car cela pourrait entraîner une surcharge de performances énorme et de nombreux objets de déchets sont créés juste pour initialiser la carte.

5. Le Java 9 Way

Java 9 est livré avec diverses méthodes d'usine dans l'interfaceMap, qui simplifie la création et l'initialisation de cartes immuables.

Allons-y et examinons ces méthodes d'usine.

5.1. Map.of()

Cette méthode d'usine ne prend aucun argument, un seul argument et des arguments variables:

Map emptyMap = Map.of();
Map singletonMap = Map.of("key1", "value");
Map map = Map.of("key1","value1", "key2", "value2");

Notez que cette méthode ne prend en charge qu'un maximum de 10 paires clé-valeur.

5.2. Map.ofEntries()

Il est similaire auMap.of() mais n'a pas de limitation du nombre de paires clé-valeur:

Map map = Map.ofEntries(
  new AbstractMap.SimpleEntry("name", "John"),
  new AbstractMap.SimpleEntry("city", "budapest"),
  new AbstractMap.SimpleEntry("zip", "000000"),
  new AbstractMap.SimpleEntry("home", "1231231231")
);

Notez que les méthodes d'usine produisent des cartes immuables, donc toute mutation entraînera unUnsupportedOperationException.

En outre, ils n'autorisent pas les clés nulles ni les clés dupliquées.

Maintenant, si nous avons besoin d'une carte mutable ou croissante après l'initialisation, nous pouvons créer l'une des implémentations de l'interfaceMap et passer ces cartes immuables dans le constructeur:

Map map = new HashMap (
  Map.of("key1","value1", "key2", "value2"));
Map map2 = new HashMap (
  Map.ofEntries(
    new AbstractMap.SimpleEntry("name", "John"),
    new AbstractMap.SimpleEntry("city", "budapest")));

6. Utilisation de goyave

Maintenant que nous avons examiné les façons d'utiliser Java de base, allons de l'avant et initialisons une carte à l'aide d'Apache Guava:

Map articles
  = ImmutableMap.of("Title", "My New Article", "Title2", "Second Article");

Cela créerait une carte immuable et créerait une carte modifiable:

Map articles
  = Maps.newHashMap(ImmutableMap.of("Title", "My New Article", "Title2", "Second Article"));

La méthodeImmutableMap.of() met var-args sous la forme clé1, valeur1, clé2, valeur2 et ainsi de suite:

ImmutableMap.of("key1", "value1", "key2", "value2");

7. Conclusion

Dans cet article, nous avons passé en revue les différentes manières d'initialiser unMap, notamment pour créer des maps vides, singleton, immuables et mutables. As you can see, there’s a huge improvement in this field since Java 9.

Comme toujours, l'exemple de code source se trouve dans lesGithub project. Les exemples Java 9 sont situéshere et l'échantillon Guavahere.

TOC

Initialiser un HashMap en Java