Java HashMap: put, get, iterar e padrões comuns

Um Map armazena pares chave-valor

Um HashMap (de java.util) armazena associações: cada chave é mapeada para um valor, e você busca os valores pela chave em tempo aproximadamente constante. Pense em um dicionário: a palavra é a chave e a definição é o valor.

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Os dois parâmetros de tipo são <KeyType, ValueType>. Aqui as chaves são String e os valores são Integer. Assim como com ArrayList, você normalmente declara a variável com o tipo da interface Map e constrói um HashMap.

put, get e sobrescrita

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // mesma chave -> sobrescreve o valor antigo

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - chave não existe
    }
}

Duas coisas para internalizar:

• Uma chave é única. put com uma chave existente substitui o valor dela e retorna o antigo.
• get em uma chave inexistente retorna null, não um erro. Fazer o auto-unboxing desse null para um int lança uma NullPointerException, uma fonte comum de bugs.

getOrDefault evita a armadilha do null

Em vez de verificar null toda vez, peça um valor padrão:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

Essa é a maneira mais limpa de lidar com buscas de itens "talvez presentes", e leva diretamente ao padrão mais famoso de HashMap.

Contar ocorrências

Contar quantas vezes cada item aparece é a tarefa clássica de um HashMap:

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

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

O padrão map.put(key, map.getOrDefault(key, 0) + 1) se lê como "pegue a contagem atual (ou zero), some um e guarde de volta". Um equivalente mais elegante é counts.merge(word, 1, Integer::sum).

Verificar e remover

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) só escreve quando a chave não existe, útil para inicialização preguiçosa.

Percorrer um HashMap

O laço mais comum percorre entrySet(), fornecendo cada chave e valor juntos:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Se você precisa apenas das chaves ou apenas dos valores:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

Você também pode usar forEach com uma lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

O HashMap não mantém a ordem

Um HashMap não garante nenhuma ordem de iteração: é a que o hashing produz, e ela pode mudar entre execuções. Se você precisa de uma ordem previsível:

• LinkedHashMap preserva a ordem de inserção.
• TreeMap mantém as chaves ordenadas pela ordem natural (ou por um Comparator que você fornecer).

As três implementam a interface Map, então trocar entre elas é uma alteração de uma única linha no construtor.

As chaves precisam ser hasheáveis

HashMap encontra as entradas fazendo o hash da chave, então o hashCode() e o equals() de uma chave precisam ser consistentes entre si. Tipos nativos como String e Integer já fazem isso corretamente. Se você usar sua própria classe como chave, sobrescreva tanto equals quanto hashCode; caso contrário, dois objetos que são "iguais" em significado vão parar em buckets diferentes e suas buscas vão falhar de forma misteriosa.

A seguir: HashSet

Um HashMap responde "qual valor está armazenado sob esta chave?". Quando você só se importa se algo está presente ou não (um conjunto de valores únicos, sem dados associados), a ferramenta é HashSet, que vem a seguir.