C'est une question simple, J'ai un simple HashMap dont je veux inverser les clés et les valeurs.
HashMap<Character, String> myHashMap = new HashMap<Character, String>();
myHashMap.put('a', "test one");
myHashMap.put('b', "test two");
et je veux créer un nouveau HashMap dans lequel je mets les contraires.
HashMap<String, Character> reversedHashMap = new HashMap<String, Character>();
e.g. Keys "test one" & "test two" and values 'a' & 'b'.
Ils sont tous uniques, oui
Si vous êtes certain que vos valeurs sont uniques, vous pouvez parcourir les entrées de votre ancienne carte.
Map<String, Character> myNewHashMap = new HashMap<>();
for(Map.Entry<Character, String> entry : myHashMap.entrySet()){
myNewHashMap.put(entry.getValue(), entry.getKey());
}
Vous pouvez également utiliser une carte bidirectionnelle comme Guava fournit et utiliser la méthode inverse()
:
BiMap<Character, String> myBiMap = HashBiMap.create();
myBiMap.put('a', "test one");
myBiMap.put('b', "test two");
BiMap<String, Character> myBiMapInversed = myBiMap.inverse();
Comme Java-8 est sorti, vous pouvez aussi le faire de cette façon:
Map<String, Integer> map = new HashMap<>();
map.put("a",1);
map.put("b",2);
Map<Integer, String> mapInversed =
map.entrySet()
.stream()
.collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey))
Enfin, j'ai ajouté ma contribution à la bibliothèque proton pack library , qui contient des méthodes utilitaires pour l'API Stream. Avec ça tu pourrais le faire comme ça:
Map<Character, String> mapInversed = MapStream.of(map).inverseMapping().collect();
La bibliothèque de collections Apache commons fournit une méthode utilitaire pour inverser la carte. Vous pouvez l'utiliser si vous êtes sûr que les valeurs de myHashMap sont uniques.
org.Apache.commons.collections.MapUtils.invertMap(Java.util.Map map)
Exemple de code
HashMap<String, Character> reversedHashMap = MapUtils.invertMap(myHashMap)
Si les valeurs ne sont pas uniques, le moyen sûr d'inverser la carte consiste à utiliser la fonction groupingBy de Java 8.
Map<String, Integer> map = new HashMap<>();
map.put("a",1);
map.put("b",2);
Map<Integer, List<String>> mapInversed =
map.entrySet()
.stream()
.collect(Collectors.groupingBy(Map.Entry::getValue, Collectors.mapping(Map.Entry::getKey, Collectors.toList())))
J'ai écrit une boucle plus simple qui fonctionne aussi (notez que toutes mes valeurs sont uniques):
HashMap<Character, String> myHashMap = new HashMap<Character, String>();
HashMap<String, Character> reversedHashMap = new HashMap<String, Character>();
for (char i : myHashMap.keySet()) {
reversedHashMap.put(myHashMap.get(i), i);
}
Pour répondre à votre question sur la manière de procéder, vous pouvez obtenir le entrySet de votre carte, puis l'insérer dans la nouvelle carte en utilisant getValue as key
et getKey as value
.
Mais rappelez-vous que les clés dans/ Map sont uniques, ce qui signifie que si vous avez une valeur avec deux clés différentes dans votre carte d'origine, seule la deuxième clé (dans l'ordre des itérations) sera conservée comme valeur dans la nouvelle carte.
Parcourez la liste des clés et des valeurs, puis ajoutez-les.
HashMap<String, Character> reversedHashMap = new HashMap<String, Character>();
for (String key : myHashMap.keySet()){
reversedHashMap.put(myHashMap.get(key), key);
}
private <A, B> Map<B, A> invertMap(Map<A, B> map) {
Map<B, A> reverseMap = new HashMap<>();
for (Map.Entry<A, B> entry : map.entrySet()) {
reverseMap.put(entry.getValue(), entry.getKey());
}
return reverseMap;
}
Il est important de se rappeler que put
remplace la valeur lorsqu'elle est appelée avec la même clé. Donc, si votre carte a deux clés avec la même valeur, une seule d'entre elles existera dans la carte inversée.
Testé avec l'extrait de code ci-dessous, testé avec MapUtils et la fonctionnalité Java8 Stream. Cela a fonctionné avec les deux cas.
public static void main(String[] args) {
Map<String, String> test = new HashMap<String, String>();
test.put("a", "1");
test.put("d", "1");
test.put("b", "2");
test.put("c", "3");
test.put("d", "4");
test.put("d", "41");
System.out.println(test);
Map<String, String> test1 = MapUtils.invertMap(test);
System.out.println(test1);
Map<String, String> mapInversed =
test.entrySet()
.stream()
.collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
System.out.println(mapInversed);
}
Output:
{a=1, b=2, c=3, d=41}
{1=a, 2=b, 3=c, 41=d}
{1=a, 2=b, 3=c, 41=d}