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 ma­nu­ten­ção das suas listas, como também lhe oferece várias opções de acesso. Aqui, apre­sen­ta­mos os métodos mais im­por­tan­tes.

O que é Java HashMap?

Existem vários métodos di­fe­ren­tes para armazenar dados e consultá-los depois. Algumas formas de ar­ma­ze­na­mento são mais adequadas do que outras, de­pen­dendo da fi­na­li­dade pre­ten­dida. Em muitos casos, a classe Java HashMap é a melhor solução. Di­fe­ren­te­mente 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 é ne­ces­sá­rio consultar um valor, basta utilizar a chave cor­res­pon­dente, que sempre retornará o resultado desejado. As chaves e os valores podem consistir de tipos de dados muito di­fe­ren­tes, 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 pro­gra­ma­ção. Além disso, a abordagem de chaves e valores impede que mais de uma chave seja associada ao mesmo valor. Portanto, é im­pos­sí­vel haver du­pli­ca­tas de chaves. Apenas objetos podem ser adi­ci­o­na­dos várias vezes, com chaves di­fe­ren­tes. Também em termos de de­sem­pe­nho, esse tipo de ar­ma­ze­na­mento 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, mos­tra­re­mos como criar Java HashMaps e usá-los para diversas fi­na­li­da­des.

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 res­pec­tivo valor.

Criar um novo Java HashMap

Para entender melhor o fun­ci­o­na­mento 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 ne­ces­sá­rio. Essa lista consiste dos nomes dos clientes, acom­pa­nha­dos dos res­pec­ti­vos números de cliente. Enquanto o número do cliente (em nosso exemplo, a chave) sempre é único, te­o­ri­ca­mente, 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 ar­ma­ze­na­dos como o tipo de dados integer (números inteiros), enquanto os nomes são salvos como strings (cadeias de ca­rac­te­res). O Java HashMap cor­res­pon­dente 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á com­ple­ta­mente 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);
	}
}

Uti­li­za­mos 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 se­pa­ra­da­mente. Para isso, for­ne­ce­mos 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 es­pe­cí­fi­cas ou todas as entradas

Se você deseja remover uma entrada es­pe­cí­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 di­fe­ren­tes. 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 iso­la­da­mente

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 exis­tên­cia de elemento

Além de acessar entradas es­pe­cí­fi­cas, você também pode verificar se um elemento está contido ou não no Java HashMap. Para isso, utilize os métodos con­tains­Key() (para chaves) e con­tains­Va­lue() (para valores). Se o elemento existir no mapa, re­ce­be­re­mos 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