Map.entrySet în Java

Set<Map.Entry<K, V>> entrySet()

static <K, V> Map.Entry<K, V> entry(K k, V v)

// în Map.Entry
K getKey()
V getValue()
V setValue(V value)

Ce face Map.entrySet

entrySet() returnează mulțimea perechilor. Fiecare pereche este un Map.Entry<K, V> cu getKey() și getValue(). Este felul obișnuit de a parcurge un map când îți trebuie și cheia, și valoarea: for (Map.Entry<String, Integer> e : map.entrySet()) (sau mai scurt, cu var e).

Pe perechile unui map modificabil, e.setValue(x) schimbă valoarea direct în map. Ca și celelalte vederi, entrySet() permite ștergerea (removeIf), dar nu adăugarea.

Map.entry(k, v) creează o pereche independentă și nemodificabilă. Este utilă pentru Map.ofEntries, pentru a returna două valori dintr-o metodă sau pentru a sorta perechi.

Parametri

Parametru	Descriere
k, v	Pentru Map.entry: cheia și valoarea (fără null).

Ce returnează

entrySet: o vedere Set<Map.Entry<K, V>>. entry: o pereche nouă.

Exemple

Exemplul 1: Parcurgerea perechilor și setValue

import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        Map<String, Double> preturi = new TreeMap<>(Map.of("cafea", 12.0, "ceai", 8.0, "suc", 9.5));
        for (Map.Entry<String, Double> e : preturi.entrySet()) {
            System.out.println(e.getKey() + " costă " + e.getValue() + " lei");
            e.setValue(e.getValue() + 1);
        }
        System.out.println("După scumpire: " + preturi);
    }
}

Rezultat

cafea costă 12.0 lei
ceai costă 8.0 lei
suc costă 9.5 lei
După scumpire: {cafea=13.0, ceai=9.0, suc=10.5}

Exemplul 2: Sortarea perechilor după valoare

Copiem perechile într-o listă și le sortăm descrescător după valoare cu Map.Entry.comparingByValue().

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> puncte = Map.of("Ana", 87, "Radu", 95, "Elena", 72, "Mihai", 90);
        List<Map.Entry<String, Integer>> lista = new ArrayList<>(puncte.entrySet());
        lista.sort(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder()));
        for (var e : lista) {
            System.out.println(e.getKey() + ": " + e.getValue());
        }
    }
}

Rezultat

Radu: 95
Mihai: 90
Ana: 87
Elena: 72

Exemplul 3: Map.entry pentru a returna o pereche

import java.util.List;
import java.util.Map;

public class Main {
    static Map.Entry<String, Integer> ceaMaiMare(Map<String, Integer> temperaturi) {
        Map.Entry<String, Integer> max = null;
        for (var e : temperaturi.entrySet()) {
            if (max == null || e.getValue() > max.getValue()) {
                max = Map.entry(e.getKey(), e.getValue());
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Map<String, Integer> t = Map.of("Iași", 24, "Constanța", 29, "Brașov", 19);
        Map.Entry<String, Integer> max = ceaMaiMare(t);
        System.out.println("Cel mai cald: " + max.getKey() + ", " + max.getValue() + " °C");
        System.out.println(List.of(Map.entry("a", 1), Map.entry("b", 2)));
    }
}

Rezultat

Cel mai cald: Constanța, 29 °C
[a=1, b=2]

Greșeli frecvente

• Parcurgi keySet() și apelezi map.get(k) pentru fiecare cheie. Merge, dar entrySet() dă direct ambele valori.
• Apelezi setValue pe o pereche creată cu Map.entry sau venită din Map.of. Apare UnsupportedOperationException.

Comenzi înrudite

• Map.forEach: Parcurge toate perechile unui map și apelează o funcție cu cheia și valoarea fiecăreia: map.forEach((k, v) -> …).
• Map.keySet: keySet() dă mulțimea cheilor unui map, values() colecția valorilor. Sunt vederi legate de map, nu copii.
• Map.of: Creează un map nemodificabil din perechi date direct (of, ofEntries) sau copiind alt map (copyOf). Ordinea nu este garantată.
• Map: Interfața pentru dicționare: perechi cheie → valoare, în care găsești rapid valoarea după cheie. Cheile sunt unice.
• Comparator: Interfața care spune cum se ordonează două obiecte: compare(a, b) returnează un număr negativ, zero sau pozitiv.