Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Chaves vizinhas em NavigableMap

Encontra a chave guardada mais próxima abaixo ou acima da chave procurada, incluindo ou excluindo as chaves que lhe são iguais na comparação.

Versão: Java SE 21

Sintaxe

K lowerKey(K key);
K floorKey(K key);
K ceilingKey(K key);
K higherKey(K key);

Os métodos de java.util.NavigableMap<K, V> procuram entre as chaves guardadas. A chave de pesquisa q não tem de estar no mapa. lowerKey(q) devolve a maior chave < q, floorKey(q) a maior chave <= q, ceilingKey(q) a menor chave >= q e higherKey(q) a menor chave > q.

Estas relações seguem a ordenação do mapa: a ordem natural das chaves ou a ordem definida por um Comparator. Para efeitos da pesquisa, duas chaves são iguais se a comparação devolver 0. Nesse caso, floorKey e ceilingKey podem devolver a chave guardada, ao passo que lowerKey e higherKey a excluem.

Estes métodos devolvem apenas uma chave do tipo K, não um valor nem um par chave–valor. Se nenhuma chave satisfizer a condição, incluindo quando o mapa está vazio, o resultado é null. Se o mapa aceitar null como chave, esse resultado também pode indicar que a chave null foi encontrada. Para obter a chave e o valor ou distinguir os dois casos, usa o método correspondente lowerEntry, floorEntry, ceilingEntry ou higherEntry: devolve um Map.Entry<K, V> quando encontra uma chave e null quando não encontra nenhuma.

Não encontrar uma chave não é o mesmo que passar um argumento inválido: um argumento null pode provocar uma NullPointerException se o mapa não aceitar chaves null. Por exemplo, no JDK 21, os quatro métodos devolvem null num TreeMap vazio com ordenação natural, mesmo que o argumento seja null, porque não há nenhuma chave guardada com que o comparar. Uma chave que não possa ser comparada com as do mapa provoca uma ClassCastException.

Exemplos

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

public class NeighborKeys {
    public static void main(String[] args) {
        NavigableMap<Integer, String> map = new TreeMap<>();
        map.put(10, "A");
        map.put(50, "B");
        map.put(90, "C");

        printNeighbors(map, 75);
        printNeighbors(map, 50);
        System.out.println("lowerKey(10): " + map.lowerKey(10));
        System.out.println("higherKey(90): " + map.higherKey(90));
    }

    private static void printNeighbors(NavigableMap<Integer, String> map, int key) {
        System.out.println(key + ": " + map.lowerKey(key) + " / " + map.floorKey(key)
                + " / " + map.ceilingKey(key) + " / " + map.higherKey(key));
    }
}

Resultado

75: 50 / 50 / 90 / 90
50: 10 / 50 / 50 / 90
lowerKey(10): null
higherKey(90): null

Os resultados são apresentados pela ordem `lowerKey`, `floorKey`, `ceilingKey`, `higherKey`. Para `75`, obtém-se `50 / 50 / 90 / 90`. Para a chave guardada `50`, só os métodos que admitem igualdade devolvem `50`. Não há uma chave vizinha abaixo de `10` nem acima de `90`, pelo que os dois últimos resultados são `null`.

Lições relacionadas

  • Java · Lição 20 · Avançado · Versão: 2

Fontes