Comment initialiser directement un HashMap (de manière littérale)? [dupliquer]
Cette question a déjà une réponse ici:
- Comment puis-je initialiser une carte statique? 41 réponses
Existe-t-il un moyen d'initialiser un HashMap Java comme celui-ci?:
Map<String,String> test =
new HashMap<String, String>{"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 sont connus à l'avance lors de la création de la carte.
6 answers
Non, vous devrez ajouter tous les éléments manuellement. Vous pouvez cependant utiliser un initialiseur statique:
public class Demo
{
private static final Map<String, String> myMap;
static
{
myMap = new HashMap<String, String>();
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<String, String> myMap = createMap();
private static Map<String, String> createMap()
{
Map<String,String> myMap = new HashMap<String,String>();
myMap.put("a", "b");
myMap.put("c", "d");
return myMap;
}
}
Java 9
Dans Java 9, quelques méthodes d'usine sont ajoutées qui peuvent également être utilisées pour simplifier la création de cartes:
public class Demo {
private static final Map<String, String> test = Map.of("a", "b", "c", "d");
private static final Map<String, String> test2 = Map.ofEntries(
entry("a", "b"),
entry("c", "d")
);
}
Dans l'exemple ci-dessus, test et test2 seront les mêmes, juste avec différentes façons d'exprimer la carte. Le La méthode Map.of est définie pour un maximum de dix éléments dans la carte, tandis que la méthode Map.ofEntries n'aura pas une telle limite.
Notez que dans ce cas, la carte résultante sera une carte immuable. Si vous voulez que la carte soit mutable, vous pouvez la copier à nouveau, par exemple en utilisant mutableMap = new HashMap<>(Map.of("a", "b"));
C'est à sens unique.
HashMap<String, String> h = new HashMap<String, String>() {{
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 la goyave:
Map<String, Integer> left = ImmutableMap.of("a", 1, "b", 2, "c", 3);
Si vous autorisez les bibliothèques tierces, vous pouvez utiliser Guava ' s ImmutableMap pour obtenir une brièveté littérale:
Map<String, String> test = ImmutableMap.of("k1", "v1", "k2", "v2");
Œuvres de 5 paires clé/valeur, sinon, vous pouvez utiliser ses constructeur:
Map<String, String> test = ImmutableMap.<String, String>builder()
.put("k1", "v1")
.put("k2", "v2")
...
.build();
- notez que l'implémentation de Goyava ImmutableMap diffère de l'implémentation de Java HashMap (notamment elle est immuable et n'autorise pas les clés/valeurs nulles)
- pour plus d'informations, voir Goyava's article du guide de l'utilisateur sur ses types de collection immuables
Il n'y a pas de moyen direct de le faire - Java n'a pas de littéraux de carte (encore - je pense qu'ils ont été proposés pour Java 8).
Certaines personnes aiment ceci:
Map<String,String> test = new HashMap<String, String>(){{
put("test","test"); put("test","test");}};
Cela crée une sous-classe anonyme de HashMap, dont l'initialiseur d'instance met ces valeurs. (En passant, une carte ne peut pas contenir deux fois la même valeur, votre deuxième mettre remplacera le premier. J'utiliserai différentes valeurs pour les exemples suivants.)
La manière normale serait ceci (pour un local variable):
Map<String,String> test = new HashMap<String, String>();
test.put("test","test");
test.put("test1","test2");
Si votre test map est une variable d'instance, placez l'initialisation dans un constructeur ou un initialiseur d'instance:
Map<String,String> test = new HashMap<String, String>();
{
test.put("test","test");
test.put("test1","test2");
}
Si votre test carte est une variable de classe, mettre l'initialisation dans un initialiseur statique:
static Map<String,String> test = new HashMap<String, String>();
static {
test.put("test","test");
test.put("test1","test2");
}
Si vous voulez que votre carte ne change jamais, vous devriez après l'initialisation envelopper votre carte par Collections.unmodifiableMap(...). Vous pouvez également le faire dans un initialiseur statique:
static Map<String,String> test;
{
Map<String,String> temp = new HashMap<String, String>();
temp.put("test","test");
temp.put("test1","test2");
test = Collections.unmodifiableMap(temp);
}
(Je ne sais pas si vous pouvez maintenant rendre test final ... l'essayer et de faire rapport ici.)
Map<String,String> test = new HashMap<String, String>()
{
{
put(key1, value1);
put(key2, value2);
}
};
Une alternative, en utilisant des classes Java 7 simples et varargs: créez une classe HashMapBuilder avec cette méthode:
public static HashMap<String, String> build(String... data){
HashMap<String, String> result = new HashMap<String, String>();
if(data.length % 2 != 0)
throw new IllegalArgumentException("Odd number of arguments");
String key = null;
Integer step = -1;
for(String 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<String,String> data = HashMapBuilder.build("key1","value1","key2","value2");