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