Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Map.values() — vue des valeurs d’une map

`Map.values()` renvoie une collection liée à la map. On peut la parcourir pour additionner des compteurs sans consulter les clés ni ignorer les valeurs répétées.

Version : Java SE 21

Syntaxe

Collection<V> values();
// For an instance map of type Map<K, V>:
Collection<V> values = map.values();

Map.values est une notation abrégée pour Map.values(), une méthode d’instance de java.util.Map<K, V>. Appelle-la sans argument sur une map : map.values(). Elle renvoie une Collection<V> (V est le type des valeurs) contenant un élément par association. Des valeurs égales associées à des clés distinctes apparaissent plusieurs fois. Utilise keySet() pour les clés et entrySet() pour les couples clé-valeur.

C’est une vue, pas une copie : ajouter, remplacer ou supprimer une association dans la map se répercute sur une vue déjà obtenue. Si la suppression est prise en charge, values.remove(x) supprime une association qui correspond à la valeur, et non à la clé. Pour viser une clé précise, utilise map.remove(key). La vue ne prend en charge ni add ni addAll. Une modification non prise en charge peut lever UnsupportedOperationException.

Ne suppose pas d’ordre de parcours : HashMap n’en garantit aucun. La vue des valeurs d’une LinkedHashMap suit l’ordre de parcours actuel des entrées de la map. Le constructeur sans argument choisit par défaut l’ordre d’insertion, mais putFirst et putLast peuvent repositionner des entrées existantes. Ne modifie pas la map pendant le parcours de la vue, sauf avec remove() sur l’itérateur en cours, si cette opération est prise en charge. Sinon, le contrat général de Map ne définit pas le résultat du parcours.

Si seules les valeurs t’intéressent, par exemple pour additionner quatre compteurs, une boucle for-each suffit. Si les modifications ultérieures de la map ne doivent pas changer les éléments de la collection, utilise new ArrayList<>(map.values()). C’est une copie superficielle : les objets utilisés comme valeurs ne sont pas clonés.

Exemples

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> counters = new HashMap<>();
        counters.put("north", 4);
        counters.put("south", 7);
        counters.put("east", 4);
        counters.put("west", 2);

        Collection<Integer> values = counters.values();
        System.out.println(sum(values));

        counters.put("west", 5);
        System.out.println(sum(values));

        values.remove(7);
        System.out.println(counters.containsKey("south"));
    }

    private static int sum(Collection<Integer> values) {
        int total = 0;
        for (int value : values) {
            total += value;
        }
        return total;
    }
}

Résultat

17
20
false

La première somme (`17`) compte les deux valeurs `4`. Après le passage de `west` de `2` à `5`, la même vue donne `20`. `values.remove(7)` supprime l’association de `south`, la seule de valeur `7`, si bien que le test de présence de la clé affiche `false`.

Leçons associées

  • Java · Leçon 58 · Débutant · Version : 2
  • Java · Leçon 39 · Intermédiaire · Version : 2

Sources