Interface Map e classe HashMap em Java

A interface Map<K, V> representa um mapeamento, ou dicionário, em que cada elemento consiste em um par chave-valor. Todas as chaves são únicas dentro do objeto Map. Essas coleções facilitam a busca de elementos quando a chave, que atua como identificador único, é conhecida.

Diferentemente de outras interfaces que representam coleções, a interface Map não estende a interface Collection.

Entre os métodos da interface Map, destacam-se:

void clear(): remove todos os elementos da coleção.
boolean containsKey(Object k): retorna true se a coleção contém a chave k.
boolean containsValue(Object v): retorna true se a coleção contém o valor v.
Set<Map.Entry<K, V>> entrySet(): retorna um conjunto com todos os elementos da coleção, cada um como objeto Map.Entry.
boolean equals(Object obj): retorna true se a coleção for idêntica à coleção passada no parâmetro obj.
boolean isEmpty(): retorna true se a coleção estiver vazia.
V get(Object k): retorna o valor associado à chave k. Caso não exista, retorna null.
V getOrDefault(Object k, V defaultValue): retorna o valor associado à chave k. Caso não exista, retorna defaultValue.
V put(K k, V v): adiciona um novo objeto com chave k e valor v. Se a chave já existir, o valor é substituído. Retorna o valor anterior para k, se existia; caso contrário, retorna null.
V putIfAbsent(K k, V v): adiciona um novo objeto com chave k e valor v apenas se a chave ainda não existir.
Set<K> keySet(): retorna um conjunto com todas as chaves do mapeamento.
Collection<V> values(): retorna uma coleção com todos os valores do mapeamento.
void putAll(Map<? extends K, ? extends V> map): adiciona todos os objetos do mapeamento map à coleção.
V remove(Object k): remove o objeto associado à chave k.
int size(): retorna o número de elementos na coleção.

O método put serve para inserir ou substituir um objeto, enquanto get recupera o valor pela chave. Implementações da interface Map também permitem obter conjuntos de chaves ou valores. O método entrySet retorna todos os elementos como objetos Map.Entry<K, V>.

A interface genérica Map.Entry<K, V> representa um objeto com chave do tipo K e valor do tipo V, e define métodos como:

boolean equals(Object obj): retorna true se o objeto obj, que representa Map.Entry, for idêntico ao atual.
K getKey(): retorna a chave do objeto.
V getValue(): retorna o valor do objeto.
V setValue(V v): define o valor v para o objeto atual.
int hashCode(): retorna o código hash do objeto.

Ao percorrer os objetos do mapeamento, esses métodos são utilizados para acessar chaves e valores.

Classes de mapeamentos. HashMap

A classe base para todos os mapeamentos é a classe abstrata AbstractMap, que implementa a maioria dos métodos da interface Map. A implementação mais comum é HashMap, que realiza a interface Map e herda de AbstractMap.

Um exemplo de uso da classe segue abaixo:

import java.util.*;

public class Program {

    public static void main(String[] args) {

        Map<Integer, String> states = new HashMap<Integer, String>();
        states.put(1, "Germany");
        states.put(2, "Spain");
        states.put(4, "France");
        states.put(3, "Italy");

        // obtemos o objeto pela chave 2
        String first = states.get(2);
        System.out.println(first);

        // obtemos o conjunto completo de chaves
        Set<Integer> keys = states.keySet();

        // obtemos a coleção de todos os valores
        Collection<String> values = states.values();

        // substituímos um elemento
        states.replace(1, "Poland");

        // removemos o elemento pela chave 2
        states.remove(2);

        // percorremos os elementos
        for (Map.Entry<Integer, String> item : states.entrySet()) {
            System.out.printf("Key: %d  Value: %s \n", item.getKey(), item.getValue());
        }

        Map<String, Person> people = new HashMap<String, Person>();
        people.put("1240i54", new Person("Tom"));
        people.put("1564i55", new Person("Bill"));
        people.put("4540i56", new Person("Nick"));

        for (Map.Entry<String, Person> item : people.entrySet()) {
            System.out.printf("Key: %s  Value: %s \n", item.getKey(), item.getValue().getName());
        }
    }
}

class Person {
    private String name;

    public Person(String value) {
        name = value;
    }

    String getName() {
        return name;
    }
}

No exemplo acima, demonstramos as operações mais comuns com HashMap. Inicialmente, criamos um mapa de Integer para String e o populamos com o método put(). O método get() é usado para recuperar um valor a partir de sua chave. Também vimos como obter coleções separadas de chaves (keySet()) e valores (values()). Métodos como replace() e remove() permitem a manipulação de entradas existentes.

A forma padrão de percorrer todos os pares chave-valor é iterar sobre o conjunto retornado por entrySet(). Cada item desse conjunto é um objeto Map.Entry, a partir do qual podemos obter a chave com getKey() e o valor com getValue(). O segundo mapa, de String para Person, ilustra como o HashMap pode ser usado com qualquer tipo de objeto personalizado.

Resumo

Map: Interface para mapeamentos de pares chave-valor, com chaves únicas e métodos para inserção, recuperação e manipulação.
Map.Entry: Interface que representa cada par chave-valor, com métodos para acessar e modificar componentes.
HashMap: Classe comum que implementa Map, baseada em hash para armazenamento eficiente, com exemplos de uso para tipos primitivos e personalizados.

📝 Exercícios

Tarefa

Descrição: Você tem um Map que armazena as capitais de alguns países. Percorra o mapa e imprima cada país e sua respectiva capital no formato "A capital de [PAÍS] é [CAPITAL]".

Código inicial:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, String> capitais = new HashMap<>();
        capitais.put("Brasil", "Brasília");
        capitais.put("França", "Paris");
        capitais.put("Japão", "Tóquio");

        // Use um loop for-each e o método entrySet() para percorrer o mapa.

    }
}

Resposta

Solução:

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, String> capitais = new HashMap<>();
        capitais.put("Brasil", "Brasília");
        capitais.put("França", "Paris");
        capitais.put("Japão", "Tóquio");

        // O método entrySet() retorna um Set de todos os pares chave-valor.
        for (Map.Entry<String, String> par : capitais.entrySet()) {
            String pais = par.getKey();
            String capital = par.getValue();
            System.out.println("A capital de " + pais + " é " + capital);
        }
    }
}