CKTIS / Java
Map.get — recuperare un valore tramite la chiave
Usa `map.get(key)` per recuperare un valore memorizzato. Se la mappa ammette valori `null`, il solo risultato non distingue una chiave assente da una associata a `null`.
Versione: Java SE 21
Sintassi
V get(Object key); // instance method declared by java.util.Map<K, V>
map.get(key) // call with one key argumentIn Java SE 21, Map.get è un metodo di istanza di java.util.Map<K, V>, dichiarato come V get(Object key). Map.get() è un’abbreviazione, non un overload senza argomenti: la chiamata corretta è map.get(key). Restituisce il valore memorizzato o null se l’associazione non esiste. Il contratto di Map descrive la corrispondenza tramite Objects.equals(key, k), dove k è la chiave memorizzata. In una HashMap, un’istanza di chiave diversa ma uguale può trovare la stessa voce. Chiavi uguali secondo equals devono avere lo stesso hashCode. Non modificare le proprietà che influiscono sull’uguaglianza di una chiave mentre è nella mappa.
Con Map<Integer, Long>, Long total = totals.get(7); recupera un valore calcolato in precedenza senza cast. Il parametro è di tipo Object, non K. Una Map di tipo raw, senza argomenti di tipo, restituisce Object. Per assegnare il risultato a una variabile di tipo String o Integer, usa un cast esplicito, come (String) raw.get(key) o (Integer) raw.get(key). Un valore incompatibile e diverso da null provoca ClassCastException durante il cast. Preferisci le mappe con argomenti di tipo.
Se la mappa ammette valori null, get non distingue una chiave assente da una associata a null. Verifica la presenza con containsKey(key); se la mappa cambia in modo concorrente, le due chiamate non formano un’operazione atomica. getOrDefault(key, fallback) restituisce fallback solo se manca l’associazione. A seconda dell’implementazione, un tipo di chiave non adatto può causare ClassCastException e una chiave null non ammessa può causare NullPointerException. Leggi i valori true e false tramite le rispettive chiavi, senza affidarti all’ordine di iterazione. L’unboxing di un risultato null, ad esempio da Boolean a boolean, genera NullPointerException.
In una LinkedHashMap ordinata per accesso (accessOrder = true nel costruttore), una ricerca riuscita sposta la voce in fondo all’ordine di iterazione, anche se il valore è null. Se la voce non viene trovata, l’ordine non cambia. Nella modalità per ordine di inserimento, get non modifica l’ordine.
Se più thread scrivono risultati, usa per esempio una ConcurrentHashMap, che non ammette chiavi o valori null. Dopo che il thread principale è tornato con successo da join() per ogni thread di lavoro, le scritture di questi thread gli sono visibili. Recupera i risultati per indice di richiesta crescente per seguire l’ordine delle richieste, non quello di completamento. join() non rende sicure le precedenti scritture concorrenti in una normale HashMap.
Esempi
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class MapGetDemo {
record Key(int id) {}
public static void main(String[] args) {
Map<Key, Long> totals = new HashMap<>();
totals.put(new Key(7), 6L * 7);
totals.put(new Key(8), null);
Long total = totals.get(new Key(7));
System.out.println("total: " + total);
for (int id : new int[] {8, 9}) {
Key key = new Key(id);
System.out.println(id + ": " + totals.get(key) + ", present: " + totals.containsKey(key));
}
Map<String, Boolean> flags = Map.of("a", true, "b", false);
System.out.println("flags: " + flags.get("a") + ", " + flags.get("b"));
Map<String, Integer> recent = new LinkedHashMap<>(16, 0.75f, true);
recent.put("a", 1);
recent.put("b", 2);
System.out.println("before: " + recent.keySet());
System.out.println("get a: " + recent.get("a"));
System.out.println("after: " + recent.keySet());
}
}Risultato
total: 42 8: null, present: true 9: null, present: false flags: true, false before: [a, b] get a: 1 after: [b, a]
Un nuovo `Key(7)` trova il valore `42`. Per `8` e `9`, `get` restituisce `null`, ma è presente solo `8`. I flag vengono letti esplicitamente per `a` e poi per `b`. Nell’ultima mappa, leggere `a` cambia l’ordine da `[a, b]` a `[b, a]`.
Lezioni correlate
- Java · Lezione 13 · Avanzato · Versione: 2
- Java · Lezione 17 · Avanzato · Versione: 2
- Java · Lezione 18 · Avanzato · Versione: 2
- Java · Lezione 36 · Avanzato · Versione: 2
- Java · Lezione 35 · Base · Versione: 2
- Java · Lezione 42 · Base · Versione: 2
- Java · Lezione 58 · Base · Versione: 2
- Java · Lezione 40 · Intermedio · Versione: 2
- Java · Lezione 43 · Intermedio · Versione: 2
Fonti
- Map (Java SE 21 & JDK 21) — get(Object)
- Map (Java SE 21 & JDK 21) — getOrDefault(Object, V)
- HashMap (Java SE 21 & JDK 21) — get(Object)
- Object (Java SE 21 & JDK 21) — hashCode()
- LinkedHashMap (Java SE 21 & JDK 21)
- ConcurrentHashMap (Java SE 21 & JDK 21) — get(Object)
- Java Language Specification, Java SE 21 — §4.8 Raw Types
- Java Language Specification, Java SE 21 — Chapter 5. Conversions and Contexts
- Java Language Specification, Java SE 21 — §17.4.5 Happens-before Order