L'interface Map en Java, et sa classe d'implémentation HashMap, propose des opérations bien connues comme put et get. Cependant, plusieurs méthodes plus spécialisées offrent des fonctionnalités élégantes pour des cas d'usage précis, en particulier avec les fonctions lambda.

1. **compute(K cle, BiFunction remap)**Cette méthode calcule et associe une valeur pour une clé donnée. La fonction de rappel reçoit la clé et sa valeur actuelle (peut être null), et doit retourner la nouvelle valeur.

Exemple d'incrémentation conditionnelle :

import java.util.HashMap;
import java.util.function.BiFunction;

HashMap<String, Integer> panier = new HashMap<>();
panier.put("pomme", 1);

BiFunction<String, Integer, Integer> calculateur = (cle, valeurActuelle) -> 
    valeurActuelle == null ? 5 : valeurActuelle + 3;

panier.compute("pomme", calculateur); // Valeur devient 4
panier.compute("poire", calculateur); // Nouvelle entrée avec la valeur 5

2. **computeIfAbsent(K cle, Function creer)**Exécute la fonction de création seulement si la clé n'est pas déjà présente ou associée à null. Idéale pour l'initialisation paresseuse.

Exemple de création de liste :

import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

HashMap<String, List<String>> annuaire = new HashMap<>();

Function<String, List<String>> fournisseurListe = cle -> new ArrayList<>();

annuaire.computeIfAbsent("amis", fournisseurListe).add("Alice");
annuaire.computeIfAbsent("collègues", fournisseurListe).add("Bob");

3. **computeIfPresent(K cle, BiFunction transformer)**Applique la fonction de transformation uniquemant si la clé existe déjà avec une valeur non-nulle.

Exemple de mise à jour de statut :

import java.util.HashMap;
import java.util.function.BiFunction;

HashMap<String, Boolean> compteActif = new HashMap<>();
compteActif.put("utilisateur_123", true);

BiFunction<String, Boolean, Boolean> toggle = (cle, etat) -> !etat;

compteActif.computeIfPresent("utilisateur_123", toggle); // Passe à false
compteActif.computeIfPresent("utilisateur_inconnu", toggle); // Aucun effet

4. **merge(K cle, V valeur, BiFunction fusionner)**Combine la valeur fournie avec la valeur existante (si elle existe) via la fonction de fusion. Utile pour l'agrégation.

Exemple d'accumulation de scores :

import java.util.HashMap;
import java.util.function.BiFunction;

HashMap<String, Integer> scores = new HashMap<>();
scores.put("JoueurA", 150);

BiFunction<Integer, Integer, Integer> addition = Integer::sum;

scores.merge("JoueurA", 30, addition); // Score total: 180
scores.merge("JoueurB", 20, addition); // Nouveau score: 20
scores.merge("JoueurA", -10, addition); // Score ajusté: 170

Ces méthodes favorisent un style de progrmamation fonctionnel et réduisent le code de vérification de présence des clés, menant à des implémentations plus concises et intentionnelles.