KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Dynamische bereikweergaven in NavigableMap

Gebruik `subMap`, `headMap` en `tailMap` om een sleutelbereik te kiezen, de grenzen expliciet in of uit te sluiten en met de oorspronkelijke map te werken in plaats van met een kopie.

Versie: Java SE 21

Syntax

import java.util.NavigableMap;
import java.util.SortedMap;

// Overloads declared by NavigableMap<K,V>:
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive);
NavigableMap<K,V> headMap(K toKey, boolean inclusive);
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);

// Overloads with fixed boundary rules:
SortedMap<K,V> subMap(K fromKey, K toKey); // [fromKey, toKey)
SortedMap<K,V> headMap(K toKey);           // keys < toKey
SortedMap<K,V> tailMap(K fromKey);         // keys >= fromKey

De methoden subMap, headMap en tailMap van de interface java.util.NavigableMap geven weergaven terug die beperkt zijn tot een sleutelbereik. De grenzen volgen de sleutelvolgorde van de map: de volgorde van de comparator of, zonder comparator, de natuurlijke volgorde van de sleutels. De TreeMap<Integer, String> uit het voorbeeld gebruikt oplopende numerieke volgorde.

subMap(fromKey, fromInclusive, toKey, toInclusive) stelt beide grenzen in, headMap(toKey, inclusive) alleen de bovengrens en tailMap(fromKey, inclusive) alleen de ondergrens. true sluit de betreffende grens in en false sluit deze uit. In het voorbeeld selecteert subMap(50, true, 100, true) het bereik [50,100], headMap(60, false) het bereik <60 en tailMap(90, true) het bereik >=90.

De overloads met boolean-argumenten geven NavigableMap<K,V> terug. Voor de kortere overloads declareert de interface SortedMap<K,V> als retourtype: subMap(fromKey, toKey) selecteert [fromKey, toKey), headMap(toKey) sleutels < toKey en tailMap(fromKey) sleutels >= fromKey.

Een weergave blijft gekoppeld aan de oorspronkelijke map en is geen kopie. Als de map een wijzigingsbewerking ondersteunt, werkt een wijziging via de weergave door in de oorspronkelijke map. Wijzigingen aan sleutels binnen het bereik in de oorspronkelijke map zijn zichtbaar in de weergave. Een sleutel buiten het bereik invoegen veroorzaakt IllegalArgumentException, net als omgekeerde subMap-grenzen of een niet-toegestane grens voor een al beperkte weergave. Als beide grenzen volgens de sleutelvergelijking gelijk zijn, kan het bereik die sleutel alleen bevatten als beide grenzen inclusief zijn; de invoer is alleen zichtbaar als die bestaat.

Voorbeelden

import java.util.NavigableMap;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        NavigableMap<Integer, String> scores = new TreeMap<>();
        for (int key : new int[] {49, 50, 60, 90, 100, 101}) {
            scores.put(key, "initial");
        }

        NavigableMap<Integer, String> range = scores.subMap(50, true, 100, true);
        NavigableMap<Integer, String> below60 = scores.headMap(60, false);
        NavigableMap<Integer, String> atLeast90 = scores.tailMap(90, true);

        System.out.println("[50,100]: " + range.keySet());
        System.out.println("<60: " + below60.keySet());
        System.out.println(">=90: " + atLeast90.keySet());

        range.put(90, "updated");
        System.out.println("source[90]: " + scores.get(90));
        scores.put(55, "added");
        System.out.println("head[55]: " + below60.get(55));

        try {
            below60.put(60, "rejected");
        } catch (IllegalArgumentException e) {
            System.out.println("head.put(60): IllegalArgumentException");
        }
    }
}

Resultaat

[50,100]: [50, 60, 90, 100]
<60: [49, 50]
>=90: [90, 100, 101]
source[90]: updated
head[55]: added
head.put(60): IllegalArgumentException

Een wijziging van sleutel `90` via `range` werkt door in de oorspronkelijke map. Als je sleutel `55` aan de oorspronkelijke map toevoegt, wordt die zichtbaar in `below60`. `below60.put(60, ...)` geeft een uitzondering, ook al bestaat sleutel `60` al in de oorspronkelijke map.

Gerelateerde lessen

  • Java · Les 20 · Gevorderd · Versie: 2

Bronnen