KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Map.get — een waarde opzoeken met een sleutel

Gebruik `map.get(key)` om een opgeslagen waarde op te halen. Als de map `null`-waarden toestaat, zie je aan het resultaat alleen niet of de sleutel ontbreekt of aan `null` is gekoppeld.

Versie: Java SE 21

Syntax

V get(Object key);  // instance method declared by java.util.Map<K, V>
map.get(key)       // call with one key argument

In Java SE 21 is Map.get een instantiemethode van java.util.Map<K, V>, gedeclareerd als V get(Object key). Map.get() is een verkorte schrijfwijze, geen overload zonder argumenten: roep map.get(key) aan. De methode retourneert de opgeslagen waarde, of null als er geen koppeling is. Het contract van Map beschrijft een overeenkomst met Objects.equals(key, k), waarbij k de opgeslagen sleutel is. In een HashMap kan een andere, maar gelijke sleutelinstantie dezelfde koppeling vinden. Sleutels die volgens equals gelijk zijn, moeten dezelfde hashCode hebben. Verander geen eigenschappen die de gelijkheid van een sleutel beïnvloeden zolang die in de map staat.

Met Map<Integer, Long> haalt Long total = totals.get(7); een eerder berekende waarde op zonder cast. Het parametertype is Object, niet K. Een raw Map zonder typeargumenten retourneert Object. Gebruik voor toewijzing aan een variabele van type String of Integer een expliciete cast, zoals (String) raw.get(key) of (Integer) raw.get(key). Bij een incompatibele waarde die niet null is, veroorzaakt de cast een ClassCastException. Gebruik bij voorkeur maps met typeargumenten.

Als de map null-waarden toestaat, maakt get geen onderscheid tussen een ontbrekende sleutel en een sleutel die aan null is gekoppeld. Controleer de aanwezigheid met containsKey(key); bij gelijktijdige wijzigingen vormen de twee aanroepen geen atomaire bewerking. getOrDefault(key, fallback) retourneert fallback alleen als de koppeling ontbreekt. Afhankelijk van de implementatie kan een ongeschikt sleuteltype een ClassCastException veroorzaken en een niet-toegestane null-sleutel een NullPointerException. Lees opgeslagen waarden true en false op via hun afzonderlijke sleutels, zonder op iteratievolgorde te vertrouwen. Het uitpakken van null naar een primitief type, bijvoorbeeld van Boolean naar boolean, veroorzaakt een NullPointerException.

In een LinkedHashMap met toegangsvolgorde (accessOrder = true in de constructor) verplaatst een treffer de koppeling naar het einde van de iteratievolgorde, ook als de waarde null is. Als de sleutel ontbreekt, verandert de volgorde niet. Bij invoegvolgorde verandert get de volgorde niet.

Als meerdere threads resultaten schrijven, gebruik dan bijvoorbeeld een ConcurrentHashMap, die geen null-sleutels of null-waarden toestaat. Nadat de hoofdthread succesvol is teruggekeerd uit join() voor elke werkthread, zijn hun schrijfbewerkingen voor de hoofdthread zichtbaar. Lees resultaten op in oplopende volgorde van de aanvraagindex om de aanvraagvolgorde te volgen in plaats van de voltooiingsvolgorde. join() maakt eerdere gelijktijdige schrijfbewerkingen naar een gewone HashMap niet veilig.

Voorbeelden

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());
    }
}

Resultaat

total: 42
8: null, present: true
9: null, present: false
flags: true, false
before: [a, b]
get a: 1
after: [b, a]

Een nieuwe `Key(7)` vindt de opgeslagen waarde `42`. Voor `8` en `9` geeft `get` `null` terug, maar alleen `8` is aanwezig. De vlaggen worden expliciet opgevraagd voor `a` en daarna voor `b`. In de laatste map verandert het opvragen van `a` de volgorde van `[a, b]` in `[b, a]`.

Gerelateerde lessen

  • Java · Les 13 · Gevorderd · Versie: 2
  • Java · Les 17 · Gevorderd · Versie: 2
  • Java · Les 18 · Gevorderd · Versie: 2
  • Java · Les 36 · Gevorderd · Versie: 2
  • Java · Les 35 · Basis · Versie: 2
  • Java · Les 42 · Basis · Versie: 2
  • Java · Les 58 · Basis · Versie: 2
  • Java · Les 40 · Gemiddeld · Versie: 2
  • Java · Les 43 · Gemiddeld · Versie: 2

Bronnen