Introdução à coleção HashMap

1. Um conjunto de pares chave-valor.

Em Java, outra coleção interessante (em termos gerais) é Map. Às vezes, essa estrutura de dados também é chamada de dicionário.

É semelhante à Setcoleção, mas armazena um conjunto de "pares" de elementos em vez de um conjunto de elementos. Cada par em a Mapconsiste em dois elementos: uma "chave" e um "valor".

Digamos que você queira que seu programa armazene os nomes dos funcionários e seus salários ou os nomes de seus colegas de trabalho e suas idades. Então você precisaria de uma tabela como esta:

Cada linha contém alguns valores. Vamos nos referir ao nome como a chave do par e à idade como o valor do par .

Todo o conjunto desses pares é o nosso mapa ( Map).

A chave de um par pode ser qualquer coisa, exceto null. As chaves devem ser únicas: um mapa não pode conter duas chaves idênticas.

2. HashMapclasse

A HashMapclasse é o tipo mais popular de Mapcoleção. Por um lado, é muito semelhante ao HashSet e possui todos os seus métodos. Por outro lado, é como uma lista ( ArrayList) que pode usar palavras (ou qualquer outra coisa) como seus índices.

Você pode criar um HashMapusando uma declaração como esta:

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

Onde KeyTypeé o tipo das chaves nos pares armazenados e ValueTypeé o tipo dos valores nos pares armazenados na HashMapcoleção.

A HashMapclasse tem métodos como este:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

Adicionando elementos a umHashMap

Os elementos são adicionados a um mapa como pares usando o put()método. A chave é passada como o primeiro argumento e o valor é passado como o segundo.

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Ao adicionar um par chave-valor, se a chave já existir na coleção, o valor antigo será substituído pelo novo valor.

Esse comportamento torna HashMapum array ou uma lista cujos índices são palavras ( String) em vez de números.

3. Subconjuntos de a HashMap: o conjunto de chaves

Digamos que queremos apenas exibir todas as entradas em a HashMapna tela. Como vamos fazer isso? Para fazer isso, precisamos saber como passar por todas as entradas no arquivo HashMap. Isto pode ser feito de várias maneiras.

A maneira mais fácil é fazer um loop sobre as teclas

HashMapas entradas não são numeradas sequencialmente, portanto, um loop com um contador não funcionará aqui. Mas podemos obter um conjunto de chaves usando o keySet()método e você já sabe como iterar em um conjunto:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

O keySet()método retorna um conjunto de chaves. Você pode usar este conjunto de duas maneiras:

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. Repetindo pares chave-valor

Há também uma maneira mais complicada: você pode transformar a Mapem um conjunto de pares chave-valor e, em seguida, percorrer os elementos do conjunto, como já aprendemos.

A HashMapcoleção tem uma classe auxiliar que armazena um par chave-valor. Parece mais ou menos assim:

class Entry<KeyType, ValueType>
{
   private KeyType key;
   private ValueType value;

   public KeyType getKey()
   {
      return this.key;
   }

   public ValueType getValue()
   {
      return this.value;
   }
}

O resultado da chamada do entrySet()método em um objeto será :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

Set<Entry<KeyType, ValueType>> name = map.entrySet();

Aqui temos a Setclasse genérica com um parâmetro de tipo, que por sua vez é um tipo genérico ( Entry) com dois parâmetros de tipo.

É muito fácil para um iniciante ficar confuso sobre isso. Mas depois de descobrir, você pode escrever códigos como:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Dito isso, esse código pode ser um pouco simplificado:

Primeiro, você pode pular a criação de uma variável separada para entriese, em vez disso, chamar o entrySet()método diretamente dentro do forloop:

for(Map.Entry<String, Integer> pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Em segundo lugar, você pode usar o operador introduzido recentemente varpara inferir automaticamente o tipo do par chave-valor :

for(var pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Nada mal, hein?

5. Comparação de ArrayListeHashMap

Um HashMapse parece muito com um ArrayListque permite que strings (ou outros tipos) sejam usados ​​como índices (as chaves).

Se você usar Integerpara as chaves em a HashMap, ele se tornará ainda mais semelhante a um ArrayList. Vamos comparar:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}