Initialiser un HashMap en Java

1. Vue d'ensemble

Dans ce didacticiel, nous allons découvrir différentes manières d'initialiser un HashMap en Java.

Nous utiliserons Java 8 ainsi que Java 9.

2. L'initialiseur statique pour un HashMap statique

Nous pouvons initialiser un HashMap en utilisant un bloc de code statique :

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 elle ne fonctionnera que pour les statiques. Par conséquent, des entrées 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 nous devons essayer d'éviter cette technique d'initialisation car elle crée une classe supplémentaire anonyme à chaque utilisation, contient des références cachées à l'objet englobant et peut provoquer des problèmes de fuite de mémoire.

3. Utilisation des collections Java

Si nous devons créer une carte immuable singleton 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, et si nous essayons d'ajouter plus d'entrées, elle lancera java.lang.UnsupportedOperationException.

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

Map emptyMap = Collections.emptyMap();

4. La manière Java 8

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

4.1. Utilisation de Collectors.toMap ()

Utilisons un Stream d'un tableau String à deux dimensions 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]));

Notez ici que le type de données de la clé et de la valeur de la carte est le même.

Afin de le rendre plus générique, prenons le tableau d' objets et effectuons 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]));

En conséquence, nous créons une carte de la clé en tant que chaîne et de la valeur en tant qu'entier .

4.2. Utilisation d'un flux de Map.Entry

Ici, nous allons utiliser les instances de Map.Entry. Il s'agit d'une autre approche où nous avons différents types de clés et de valeurs.

Tout d'abord, utilisons l' implémentation SimpleEntry de l' interface Entry :

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

Créons maintenant la carte à l'aide de l' implémentation SimpleImmutableEntry :

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. Initialisation d'une carte immuable

Dans certains cas d'utilisation, nous devons initialiser une carte immuable. Cela pourrait être fait en enveloppant le Collectors.toMap () dans Collectors.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 à l'aide de Streams, 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. La manière Java 9

Java 9 est fourni avec diverses méthodes d'usine dans l' interface Map qui simplifient la création et l'initialisation de cartes immuables.

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

5.1. Carte de()

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 à Map.of () mais n'a aucune limitation sur le 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 de fabrique produisent des cartes immuables, par conséquent, toute mutation entraînera une exception UnsupportedOperationException.

En outre, ils n'autorisent pas les clés nulles ou les clés en double.

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' interface Map 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 la goyave

Alors que nous avons examiné les façons d'utiliser le noyau Java, allons de l'avant et initialisons une carte en utilisant la bibliothèque Guava:

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

Cela créerait une carte immuable et en créerait une mutable:

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

La méthode ImmutableMap.of () a également des versions surchargées qui peuvent prendre jusqu'à 5 paires de paramètres clé-valeur. Voici à quoi ressemblerait un exemple avec 2 paires de paramètres:

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

7. Conclusion

Dans cet article, nous avons exploré les différentes manières d'initialiser une carte , en particulier pour créer des cartes vides, singleton, immuables et mutables. Comme nous pouvons le voir, il y a une énorme amélioration dans ce domaine depuis Java 9.

Comme toujours, l'exemple de code source se trouve dans le projet Github. Les exemples Java 9 se trouvent ici, et l'exemple Guava ici.