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

CKTIS / Java

Map.get — consultar um valor pela chave

Usa `map.get(key)` para obter um valor guardado. Se o mapa aceitar valores `null`, o resultado por si só não distingue uma chave em falta de uma chave associada a `null`.

Versão: Java SE 21

Sintaxe

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

Em Java SE 21, Map.get é um método de instância de java.util.Map<K, V>, declarado como V get(Object key). Map.get() é uma abreviatura, não uma sobrecarga sem argumentos: chama map.get(key). O método devolve o valor guardado ou null se não existir uma associação. O contrato de Map descreve a correspondência por Objects.equals(key, k), sendo k a chave guardada. Num HashMap, uma instância distinta mas igual da chave pode encontrar a mesma entrada. Chaves iguais segundo equals têm de ter o mesmo hashCode. Não alteres as propriedades que afetam a igualdade de uma chave enquanto estiver no mapa.

Com Map<Integer, Long>, Long total = totals.get(7); obtém um valor calculado anteriormente sem conversão explícita. O parâmetro é do tipo Object, não K. Um Map de tipo bruto, sem argumentos de tipo, devolve Object. Para atribuir o resultado a uma variável do tipo String ou Integer, usa uma conversão explícita, como (String) raw.get(key) ou (Integer) raw.get(key). Se o valor for incompatível e diferente de null, a conversão lança ClassCastException. Prefere mapas com argumentos de tipo.

Se o mapa aceitar valores null, get não distingue uma chave em falta de uma associada a null. Verifica a presença com containsKey(key); se houver alterações concorrentes, as duas chamadas não formam uma operação atómica. getOrDefault(key, fallback) só devolve fallback se não existir associação. Consoante a implementação, um tipo de chave inadequado pode causar ClassCastException e uma chave null não permitida pode causar NullPointerException. Lê os valores true e false através das respetivas chaves, sem depender da ordem de iteração. O unboxing de um resultado null, por exemplo de Boolean para boolean, lança NullPointerException.

Num LinkedHashMap com ordem de acesso (accessOrder = true no construtor), uma consulta bem-sucedida desloca a entrada para o fim da ordem de iteração, mesmo que o valor seja null. Se não houver entrada, a ordem não muda. No modo de ordem de inserção, get não altera a ordem.

Se várias threads escreverem resultados, usa, por exemplo, um ConcurrentHashMap, que não admite chaves nem valores null. Quando a thread principal regressa com sucesso de join() para cada thread de trabalho, consegue ver as respetivas escritas. Consulta os resultados por índice de pedido crescente para obter a ordem dos pedidos e não a ordem de conclusão. join() não torna seguras as escritas concorrentes anteriores num HashMap normal.

Exemplos

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

Resultado

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

Um novo `Key(7)` encontra o valor `42`. Para `8` e `9`, `get` devolve `null`, mas só `8` está presente. Os indicadores são consultados explicitamente para `a` e depois para `b`. No último mapa, ler `a` altera a ordem de `[a, b]` para `[b, a]`.

Lições relacionadas

  • Java · Lição 13 · Avançado · Versão: 2
  • Java · Lição 17 · Avançado · Versão: 2
  • Java · Lição 18 · Avançado · Versão: 2
  • Java · Lição 36 · Avançado · Versão: 2
  • Java · Lição 35 · Básico · Versão: 2
  • Java · Lição 42 · Básico · Versão: 2
  • Java · Lição 58 · Básico · Versão: 2
  • Java · Lição 40 · Intermédio · Versão: 2
  • Java · Lição 43 · Intermédio · Versão: 2

Fontes