Mapas em

Sobre Mapas

Um Map é uma estrutura de dados para armazenar pares de chave e valor. É semelhante a dicionários em outras linguagens de programação. A interface Map define as operações que você pode fazer com um Map.

HashMap

Java tem várias implementações diferentes de Map. HashMap é uma das mais usadas.

// Make an instance
Map<String, Integer> fruitPrices = new HashMap<>();

HashMap também tem um construtor de cópia.

// Make a copy of a map
Map<String, Integer> copy = new HashMap<>(fruitPrices);

Adicione entradas ao Map usando put.

fruitPrices.put("apple", 100);
fruitPrices.put("pear", 80);
// => { "apple" => 100, "pear" => 80 }

Só um valor pode ser associado a cada chave. Chamar put com a mesma chave atualiza o valor da chave.

fruitPrices.put("pear", 40);
// => { "apple" => 100, "pear" => 40 }

Use get para obter o valor de uma chave.

fruitPrices.get("apple"); // => 100

Use containsKey para ver se o Map contém uma chave específica.

fruitPrices.containsKey("apple");   // => true
fruitPrices.containsKey("orange");  // => false

Remova entradas com remove.

fruitPrices.put("plum", 90);  // Add plum to map
fruitPrices.remove("plum");   // Removes plum from map

O método size retorna o número de entradas.

fruitPrices.size();  // Returns 2

Você pode usar os métodos keySet ou values para obter as chaves ou os valores de um Map como um Set ou uma coleção, respectivamente.

fruitPrices.keySet();  // Returns "apple" and "pear" in a set
fruitPrices.values();  // Returns 100 and 80, in a Collection

O HashMap usa hashCode e equals

HashMaps usam o método hashCode e equals do objeto para descobrir onde armazenar e como recuperar os valores de uma chave. Por isso, é importante que os valores de retorno deles não mudem entre armazenar e recuperar, senão o HashMap pode não conseguir encontrar o valor.

Por exemplo, digamos que temos a seguinte classe que será usada como chave de um Map:

public class Stock {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (Objects.equals(Stock.class, obj.getClass()) && obj instanceof Stock other) {
            return Objects.equals(name, other.name);
        }
        return false;
    }
}

O hashCode e o equals dependem do campo name, que pode ser alterado via setName. Alterar o hashCode pode produzir resultados surpreendentes:

Stock stock = new Stock();
stock.setName("Beanies");

Map<Stock, Integer> stockCount = new HashMap<>();
stockCount.put(stock, 80);

stockCount.get(stock); // Returns 80

Stock other = new Stock();
other.setName("Beanies");

stockCount.get(other); // Returns 80 because "other" and "stock" are equal

stock.setName("Choccies");
stockCount.get(stock); // Returns null because hashCode value has changed

stockCount.get(other);  // Also returns null because "other" and "stock" are not equal

stock.setName("Beanies");
stockCount.get(stock); // HashCode restored, so returns 80 again

stockCount.get(other); // Also returns 80 again because "other" and "stock" are back to equal

Map.of e Map.copyOf

Outra forma comum de criar Maps é usar Map.of ou Map.ofEntries.

// Using Map.of
Map<String, Integer> temperatures = Map.of("Mon", 30, "Tue", 28, "Wed", 32);

// or using Map.ofEntries
Map<String, Integer> temperatures2 = Map.ofEntries(
    Map.entry("Mon", 30),
    Map.entry("Tue", 28),
    Map.entry("Wed", 32)
);

Diferente do HashMap, eles preenchem o Map de antemão e ficam somente leitura depois de criados. Map.copyOf faz uma cópia somente leitura de um Map.

Map<String, Integer> readOnlyFruitPrices = Map.copyOf(fruitPrices);

Chamar métodos como put, remove ou clear resulta em uma UnsupportedOperationException.