Java HashMap: Armazenar e gerenciar dados em pares de chave valor

Com a classe Java HashMap, você pode armazenar dados em pares de chave valor. Isso não só facilita a consulta e a manutenção das suas listas, como também lhe oferece várias opções de acesso. Aqui, apresentamos os métodos mais importantes.

O que é Java HashMap?

Existem vários métodos diferentes para armazenar dados e consultá-los depois. Algumas formas de armazenamento são mais adequadas do que outras, dependendo da finalidade pretendida. Em muitos casos, a classe Java HashMap é a melhor solução. Diferentemente de outros métodos, essa classe armazena dados como pares de chave valor (key-value pairs). Esse conceito determina que cada chave (key) é associada a um único valor (value). Então, quando é necessário consultar um valor, basta utilizar a chave correspondente, que sempre retornará o resultado desejado. As chaves e os valores podem consistir de tipos de dados muito diferentes, como strings, números ou outros objetos.

Sendo assim, a classe Java HashMap apresenta uma série de vantagens. Em primeiro lugar, ela agiliza e facilita as buscas dentro dessa linguagem de programação. Além disso, a abordagem de chaves e valores impede que mais de uma chave seja associada ao mesmo valor. Portanto, é impossível haver duplicatas de chaves. Apenas objetos podem ser adicionados várias vezes, com chaves diferentes. Também em termos de desempenho, esse tipo de armazenamento e pesquisa é superior às listas estáticas, que são muito menos flexíveis. Essa também é uma das grandes vantagens dos bancos de dados de chave valor, que seguem o mesmo princípio. Nas seções a seguir, mostraremos como criar Java HashMaps e usá-los para diversas finalidades.

Criar e usar Java HashMap

Para criar um novo Java HashMap, primeiro você precisa importar a classe. Para isso, use o comando Java import. Então, você pode gerar o mapa com a seguinte sintaxe:

import java.util.HashMap;
HashMap<String, String> nome_do_HashMap = new HashMap<String, String> ();

Os dois tipos de dados separados por vírgula (nesse caso, String, String), são a chave e o respectivo valor.

Criar um novo Java HashMap

Para entender melhor o funcionamento da classe HashMap em Java, vamos utilizar um exemplo prático. Digamos que queremos criar uma lista de clientes que uma empresa possa consultar quando necessário. Essa lista consiste dos nomes dos clientes, acompanhados dos respectivos números de cliente. Enquanto o número do cliente (em nosso exemplo, a chave) sempre é único, teoricamente, pode haver mais de um cliente com o mesmo nome. No entanto, cada um deles receberia seu próprio número. Esses números são armazenados como o tipo de dados integer (números inteiros), enquanto os nomes são salvos como strings (cadeias de caracteres). O Java HashMap correspondente seria assim:

import java.util.HashMap;
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	}
}

Adicionar elementos

Já temos nosso Java HashMap, mas ele ainda está completamente vazio. Agora, para adicionar novos pares de chave valor, usamos o método put(). Em nosso exemplo, isso seria feito da seguinte maneira:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	System.out.println(listaclientes);
	}
}

Utilizamos o comando System.out.println para exibir nossa lista de clientes. Veremos, então, este resultado:

{1077=Sabrina Ribeiro, 15312=Pedro de Souza, 73329=Maria Goulart}

Acessar elementos

Criamos uma lista de clientes que ainda pode conter muito mais entradas, mas também queremos poder acessar cada cliente separadamente. Para isso, fornecemos a chave como argumento do método get():

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	System.out.println(listaclientes.get(1077));
	}
}

Nesse caso, somente o nome “Sabrina Ribeiro” será exibido como resultado.

Remover entradas específicas ou todas as entradas

Se você deseja remover uma entrada específica, basta usar o método remove(). Na prática, isso funciona assim:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	listaclientes.remove(1077);
	System.out.println(listaclientes);
	}
}

O resultado exibido seria o seguinte:

{15312=Pedro de Souza, 73329=Maria Goulart}

Também é possível apagar a lista inteira de uma vez. Para isso, usamos o método clear(). Vejamos como seria em nosso exemplo:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	listaclientes.clear();
	System.out.println(listaclientes);
	}
}

Nesse caso, o resultado exibido seria somente:

{ }

Descobrir número total de entradas

Nosso Java HashMap é bem pequeno, mas com essa classe, você também pode criar listas muito maiores, é claro. Nesse caso, talvez você precise descobrir o número exato de entradas diferentes. Afinal, essa seria sua base de clientes total. O método utilizado para isso é size():

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	System.out.println(listaclientes.size());
	}
}

Em nosso exemplo simples, recebemos como resultado o número 3.

Exibir chaves ou valores isoladamente

Podemos também gerar uma lista que contenha apenas as chaves ou os valores. A base para isso é um loop for-each. Para as chaves, usamos o método keySet(), e para os valores, o método values(). Vejamos como funciona este último em nosso exemplo:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	for (String i : listaclientes.values()) {
		System.out.println(i);
		}
	}
}

Nosso resultado seria, então:

Sabrina Ribeiro
Pedro de Souza
Maria Goulart

Verificar existência de elemento

Além de acessar entradas específicas, você também pode verificar se um elemento está contido ou não no Java HashMap. Para isso, utilize os métodos containsKey() (para chaves) e containsValue() (para valores). Se o elemento existir no mapa, receberemos o resultado “true”. Se o elemento não existir, o resultado será “false”. Na prática, esses dois métodos funcionam deste modo:

public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> listaclientes = new HashMap<>();
	listaclientes.put (1077, "Sabrina Ribeiro");
	listaclientes.put (15312, "Pedro de Souza");
	listaclientes.put (73329, "Maria Goulart");
	System.out.println(listaclientes.containsKey(15312));
	System.out.println(listaclientes.containsValue("Eduardo Menezes"));
	}
}

A chave “15312” realmente existe, mas o nome “Eduardo Menezes” não faz parte da lista. Portanto, o resultado será:

true
false