Comment initialiser directement un HashMap (de manière littérale)?

Existe-t-il un moyen d’initialiser un Java HashMap comme ceci?:

Map test = new HashMap{"test":"test","test":"test"}; 

Quelle serait la syntaxe correcte? Je n’ai rien trouvé à ce sujet. Est-ce possible? Je cherche le moyen le plus court / le plus rapide de mettre des valeurs “finales / statiques” dans une carte qui ne changent jamais et qui sont connues à l’avance lors de la création de la carte.

Non, vous devrez append tous les éléments manuellement. Vous pouvez cependant utiliser un initialiseur statique:

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

Notez que l’utilisation d’une fonction pour l’initialisation fera de même mais peut améliorer la lisibilité du code:

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

Java 9

En Java 9, quelques méthodes d’usine sont ajoutées pour simplifier la création de cartes:

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

Dans l’exemple ci-dessus, test et test2 seront les mêmes, avec différentes manières d’exprimer la carte. La méthode Map.of est définie pour un maximum de dix éléments dans la carte, tandis que la méthode Map.ofEnsortinges ne comporte aucune limite de ce type.

Notez que dans ce cas la carte résultante sera une carte immuable. Si vous souhaitez que la carte soit mutable, vous pouvez la copier à nouveau, par exemple en utilisant mutableMap = new HashMap<>(Map.of("a", "b"));

(Voir aussi JEP 269 et le Javadoc )

C’est un moyen.

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

Cependant, vous devez être prudent et vous assurer que vous comprenez le code ci-dessus (il crée une nouvelle classe qui hérite de HashMap). Par conséquent, vous devriez lire plus ici: http://www.c2.com/cgi/wiki?DoubleBraceInitialization , ou simplement utiliser Guava:

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

Si vous autorisez les bibliothèques tierces, vous pouvez utiliser ImmutableMap pour obtenir une brièveté littérale:

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

Cela fonctionne pour un maximum de 5 paires clé / valeur , sinon vous pouvez utiliser son générateur :

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

  • notez que l’implémentation ImmutableMap de Guava est différente de l’implémentation Java HashMap (plus particulièrement, elle est immuable et n’autorise pas les clés / valeurs null)
  • Pour plus d’informations, consultez l’article du guide de l’utilisateur de Guava sur ses types de collection immuables.

Il n’y a pas de moyen direct de le faire – Java n’a pas de littéral Map (encore – je pense qu’ils ont été proposés pour Java 8).

Certaines personnes aiment ça:

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

Cela crée une sous-classe anonyme de HashMap, dont l’initialiseur d’instance met ces valeurs. (D’ailleurs, une carte ne peut pas contenir deux fois la même valeur, votre deuxième écrasera la première. J’utiliserai des valeurs différentes pour les exemples suivants.)

La manière normale serait ceci (pour une variable locale):

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

Si votre mappe de test est une variable d’instance, placez l’initialisation dans un constructeur ou un initialiseur d’instance:

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

Si votre mappe de test est une variable de classe, placez l’initialisation dans un initialiseur statique:

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

Si vous souhaitez que votre carte ne change jamais, vous devez, après l’initialisation, envelopper votre carte par Collections.unmodifiableMap(...) . Vous pouvez également le faire dans un initialiseur statique:

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

(Je ne suis pas sûr que vous puissiez maintenant faire le test final… essayez-le et rapportez-le ici.)

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

Une alternative, en utilisant les classes Java 7 et vararg: créez une classe HashMapBuilder avec cette méthode:

 public static HashMap build(Ssortingng... data){ HashMap result = new HashMap(); if(data.length % 2 != 0) throw new IllegalArgumentException("Odd number of arguments"); Ssortingng key = null; Integer step = -1; for(Ssortingng 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; } 

Utilisez la méthode comme ceci:

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