QCM Java : Maps et methodes computeIfAbsent, merge, compute

Reponse correcte: B

La methode computeIfAbsent est specialement concue pour ajouter une entree dans un Map uniquement si la cle n’existe pas deja. Elle prend une cle et une fonction de calcul en parametres. Si la cle est absente (ou associee a null), la fonction est executee pour calculer la valeur, qui est ensuite inseree dans le Map. Cette methode est particulierement utile pour l’initialisation paresseuse (lazy initialization) de valeurs.

Exemple de code:

Map<String, List<String>> map = new HashMap<>();

// Sans computeIfAbsent (verbose)
if (!map.containsKey("fruits")) {
    map.put("fruits", new ArrayList<>());
}
map.get("fruits").add("pomme");

// Avec computeIfAbsent (concis)
map.computeIfAbsent("fruits", k -> new ArrayList<>()).add("pomme");

Pourquoi les autres reponses sont incorrectes:

• A. put: Cette methode ajoute ou remplace toujours la valeur, meme si la cle existe deja. Elle ne fait pas de verification prealable.
• C. computeIfPresent: Cette methode fait l’inverse - elle modifie une valeur uniquement si la cle existe deja.
• D. merge: Cette methode combine une nouvelle valeur avec une valeur existante. Elle peut aussi ajouter si la cle n’existe pas, mais son comportement principal est la fusion de valeurs.

Reponse correcte: A

La methode computeIfPresent est concue pour modifier la valeur associee a une cle, mais uniquement si cette cle existe deja dans le Map et que sa valeur n’est pas null. Elle prend une cle et une BiFunction qui recoit l’ancienne cle et l’ancienne valeur pour calculer la nouvelle valeur. Si la fonction retourne null, l’entree est supprimee du Map.

Exemple de code:

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);
scores.put("Bob", 85);

// Augmenter le score d'Alice de 10 points si elle existe
scores.computeIfPresent("Alice", (key, oldValue) -> oldValue + 10);
// scores.get("Alice") retourne maintenant 110

// Ne fait rien car "Charlie" n'existe pas
scores.computeIfPresent("Charlie", (key, oldValue) -> oldValue + 10);

Pourquoi les autres reponses sont moins appropriees:

• B. replace: Bien que replace puisse aussi modifier une valeur existante, il remplace directement par une valeur fournie sans permettre de calcul base sur l’ancienne valeur.
• C. put: Cette methode remplace la valeur sans condition et ne permet pas de calculer la nouvelle valeur en fonction de l’ancienne.
• D. merge: Cette methode est plus adaptee pour combiner des valeurs qu’uniquement les modifier conditionnellement.

Reponse correcte: A

La methode compute est la plus flexible des methodes de calcul sur les Maps. Elle permet de calculer une nouvelle valeur pour une cle donnee, que la cle existe ou non dans le Map. La BiFunction recoit la cle et la valeur actuelle (qui peut etre null si la cle n’existe pas) et retourne la nouvelle valeur. Si la fonction retourne null, l’entree est supprimee.

Exemple de code:

Map<String, Integer> wordCount = new HashMap<>();

String[] words = {"java", "python", "java", "javascript", "java"};

// Compter les occurrences de chaque mot
for (String word : words) {
    wordCount.compute(word, (key, count) -> (count == null) ? 1 : count + 1);
}
// Resultat: {java=3, python=1, javascript=1}

// Equivalent plus concis avec merge:
// wordCount.merge(word, 1, Integer::sum);

Pourquoi les autres reponses sont incorrectes:

• B. replace: Cette methode remplace par une valeur fournie directement, sans possibilite de calculer la nouvelle valeur basee sur l’ancienne ou la cle.
• C. computeIfPresent: Cette methode ne fonctionne que si la cle existe deja. compute fonctionne dans tous les cas.
• D. merge: Bien que merge puisse aussi calculer des valeurs, il est specialise pour la fusion et necessite une valeur par defaut. compute est plus general.

Reponse correcte: B

Note: La formulation de cette question est ambigue. computeIfPresent permet de modifier une entree uniquement si la cle est presente. Cependant, si l’on cherche une methode qui fait les deux (ajouter si absent, modifier si present), compute ou merge seraient plus appropriees.

La methode computeIfPresent verifie d’abord si la cle existe et si sa valeur n’est pas null. Si ces conditions sont remplies, elle execute la fonction de calcul pour obtenir une nouvelle valeur. Cette methode est ideale pour les mises a jour conditionnelles ou la cle doit imperativement exister.

Exemple de code:

Map<String, Double> prices = new HashMap<>();
prices.put("laptop", 999.99);
prices.put("phone", 599.99);

// Appliquer une reduction de 10% seulement sur les produits existants
BiFunction<String, Double, Double> applyDiscount = (key, price) -> price * 0.9;

prices.computeIfPresent("laptop", applyDiscount);  // laptop = 899.991
prices.computeIfPresent("tablet", applyDiscount);  // Aucun effet (tablet n'existe pas)

Pourquoi les autres reponses sont moins appropriees:

• A. computeIfAbsent: Cette methode ne permet que d’ajouter, pas de modifier une entree existante.
• C. replace: Ne permet pas de calculer la nouvelle valeur en fonction de l’ancienne.
• D. merge: Bien que merge puisse gerer les deux cas, son comportement principal est la fusion de valeurs avec une fonction de remapping.

Reponse correcte: D

La methode merge est parfaitement adaptee pour ce cas d’usage. Elle prend trois parametres: une cle, une valeur, et une fonction de fusion. Si la cle n’existe pas (ou est associee a null), la valeur fournie est directement inseree. Si la cle existe, la fonction de fusion est executee avec l’ancienne valeur et la nouvelle valeur pour calculer le resultat final.

Exemple de code:

Map<String, Integer> inventory = new HashMap<>();

// Ajouter ou fusionner des quantites
inventory.merge("pommes", 10, Integer::sum);    // pommes = 10 (nouvelle entree)
inventory.merge("pommes", 5, Integer::sum);     // pommes = 15 (fusion: 10 + 5)
inventory.merge("oranges", 8, Integer::sum);    // oranges = 8 (nouvelle entree)

// Exemple avec concatenation de chaines
Map<String, String> messages = new HashMap<>();
messages.merge("greeting", "Hello", (old, new_) -> old + " " + new_);
messages.merge("greeting", "World", (old, new_) -> old + " " + new_);
// greeting = "Hello World"

Pourquoi les autres reponses sont incorrectes:

• A. put: Bien que put puisse ajouter ou remplacer, il ne permet pas de fusionner l’ancienne et la nouvelle valeur. Il ecrase simplement l’ancienne valeur.
• B. computeIfAbsent: Cette methode ajoute uniquement si la cle n’existe pas. Elle ne permet pas de modifier une entree existante.
• C. computeIfPresent: Cette methode modifie uniquement si la cle existe. Elle ne permet pas d’ajouter une nouvelle entree.