Introduction
Dans cet article, nous allons parler de plusieurs méthodes Java :
- computeIfAbsent
- computeIfPresent
- compute
- merge
Nous examinerons les exemples de base de chacune de ces méthodes
La méthode computeIfAbsent
Exemple en code :
public class HashMapAndConcurrent {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
int value = map.computeIfAbsent("xyz", (k) -> 10);
System.out.println("Value : " + value); // Output : Value : 10
System.out.println("Map : " + map); // Output : Map : {abc=10}
Map<String, Integer> map2 = new HashMap<>();
map2.put("abc", null);
map2.computeIfAbsent("abc", (k) -> 5);
System.out.println("Map2 : " + map2); // Output : Map2 : {abc=5}
Map<String, Integer> map3 = new HashMap<>();
map3.computeIfAbsent("pqr", (k) -> null);
System.out.println("Map3 : " + map3); // Output : Map3 : {}
}
}
La méthode computeIfAbsent prend en entrée une clé et une fonction “mapping”.
Si la clé spécifiée n’est pas présente dans la map ou si elle est mappée à une valeur null, la fonction de mappage est exécutée. Si la fonction de mappage renvoie une valeur null ou lève une exception, aucun mappage n’est enregistré.
Dans l’exemple du dessus, la clé “xyz” n’existe pas et donc, la fonction de mappage est exécutée et le résultat de celle-ci est affecté à cette clé. Ici, le type de retour de la méthode computeIfAbsent est Integer comme nous l’avons spécifié en tant que paramètre de type dans le map.
Dans le deuxième cas, la fonction de mapping est exécutée puisque la valeur de la clé “abc” est null.
Dans le troisième cas, une nouvelle entrée n’est pas ajoutée à la map car la fonction de mapping renvoie null.
Si le type de valeur de la map est une collection, vous pouvez l’utiliser pour stocker plusieurs valeurs :
public class HashMapAndCollection {
public static void main(String[] args) {
Map<String, List<Integer>> map = new HashMap<>();
List<Integer> list = Arrays.asList(10, 20, 30);
map.computeIfAbsent("abc", (k) -> new ArrayList<>()).addAll(list);
System.out.println("Map : " + map); // Output : Map : {abc=[10, 20, 30]}
}
}La méthode computeIfPresent
public class HashMapAndPresent {
public static void main(String[] args) {
Map<String, List<Integer>> map = new HashMap<>();
List<Integer> list = new ArrayList<>();
list.add(100);
map.put("abc", list);
map.computeIfPresent("abc", (key, value) ->
{
value.add(200);
return value;
});
System.out.println("Map : " + map); // Output : Map : {abc=[100, 200]}
Map<String, List<Integer>> map2 = new HashMap<>();
map2.put("xyz", null);
map2.computeIfPresent("xyz", (key, value) -> new ArrayList<>());
System.out.println("Map2 : " +map2); // Output : Map2 : {xyz=null}
Map<String, List<Integer>> map3 = new HashMap<>();
List<Integer> list1 = new ArrayList<>();
list1.add(50);
map3.put("pqr", list1);
map3.computeIfPresent("pqr", (key, value) -> null);
System.out.println("Map3 : " +map3); // Output : Map3 : {}
}
}
La méthode computeIfPresent est l’inverse de la méthode computeIfAbsent. Cette méthode prend une clé et une fonction de mappage BiFunction.
L’entrée de cette fonction de mappage est la clé que nous avons fournie et la valeur correspondante qui est présente dans la map. La fonction de mappage n’est exécutée que si la clé existe et si la valeur correspondante n’est pas null. Si la fonction de mappage donne une valeur null, le couple clé-valeur est supprimé de la map et si la fonction de mappage lève une exception, le couple clé-valeur reste inchangé dans la map.
La méthode compute :
public class ComputeHashMap {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.compute("abc", (key, value) -> {
if (value == null)
return "empty";
else
return value.concat("present");
});
System.out.println("Map:" + map); // Output : Map:{abc=empty}
Map<String, String> map2 = new HashMap<>();
map2.put("xyz", "123");
map2.compute("xyz", (key, value) -> {
return null;
});
System.out.println("Map2 : " + map2); // Output : Map2 : {}
}
}
Vous pouvez considérer la méthode compute comme une combinaison des méthodes computeIfAbsent & computeIfPresent. La méthode compute prend une clé et une fonction de mappage BiFunction.
Là encore, l’entrée de cette fonction de mappage est une clé et sa valeur correspondante. Si la valeur est null, la fonction de mappage peut être utilisée pour créer une nouvelle valeur, sinon, elle peut être utilisée pour mettre à jour/remplacer une valeur existante. Si la fonction de mappage renvoie un résultat null, la paire clé-valeur existante est supprimée. Si la fonction de mappage lève une exception, la paire clé-valeur reste inchangée.
La méthode merge
public class HashMerge {
public static void main(String[] args) {
Map<Integer, String> map1 = new HashMap<>();
map1.put(1, "X");
map1.put(2, "Y");
map1.put(3, "Z");
System.out.println("Map1 : " + map1); // Output : Map1 : {1=X, 2=Y, 3=Z}
Map<Integer, String> map2 = new HashMap<>();
map2.put(1, "A");
map2.put(2, "B");
map2.put(3, "C");
map2.put(4, "D");
System.out.println("Map2 : " + map2); // Output : Map2 : {1=A, 2=B, 3=C, 4=D}
map2.forEach((key, value) ->
{
map1.merge(key, value, (oldValue, newValue) ->
{
return oldValue.concat(",").concat(newValue);
});
});
System.out.println("Merged map1:" + map1); // Output : Merged map1:{1=X,A, 2=Y,B, 3=Z,C, 4=D}
}
}
Comme son nom l’indique, la méthode de merge est utilisée pour fusionner quelque chose dans la map. La méthode merge prend trois entrées, la première est la clé, la seconde est la valeur. Cette valeur est utilisée lorsque la clé n’existe pas dans la map ou que la valeur de cette clé est null.
La troisième est la fonction de mappage qui n’est exécutée que si la clé existe dans la map. Le résultat de cette fonction de mappage est utilisé pour mettre à jour/remplacer la valeur existante. Si le résultat de la fonction de mappage est null, la paire clé-valeur est supprimée de la map.
