# Java Hashmap: armazenar dados em pares chave-valor

Com a classe Java HashMaps, é possível guardar dados em pares chave-valor. Isso não só facilita a recuperação e a manutenção de uma lista, mas também oferece inúmeras opções de acesso. Apresentaremos os métodos mais importantes.

## O que são HashMaps em Java?

Existem diferentes métodos para armazenar e recuperar dados. Dependendo do uso que se deseja dar, usar um ou outro tipo de armazenamento pode ser mais conveniente. Em muitos casos, optar pela classe HashMap do Java pode ser a melhor solução. Ao contrário de outros métodos, esta classe armazena os dados como **pares chave-valor**, ou seja, a cada chave é atribuído exatamente um valor. Para recuperar o valor, basta usar a chave correspondente. As chaves e os valores podem ser tipos de dados muito diferentes, como cadeias, números ou outros objetos.

A classe HashMap do Java tem, portanto, várias vantagens. Em primeiro lugar, permite realizar uma pesquisa rápida dentro da estrutura da linguagem de programação. Ao mesmo tempo, a abordagem chave-valor evita que uma mesma chave receba vários valores e **, dessa forma, evita-se a duplicação**. Apenas os objetos podem ser incluídos várias vezes com chaves diferentes. No que diz respeito ao desempenho, este tipo de armazenamento e pesquisa também é vantajoso quando comparado, por exemplo, com listas rígidas, que são muito menos flexíveis. Por isso, as bases de dados chave-valor seguem este princípio. A seguir, descubra como criar HashMaps em Java e utilizá-los para os seus fins.

## Como são criados?

Para criar um novo HashMap em Java, primeiro é necessário importar a classe. Para isso, use o comando Java `import`. Em seguida, pode criar o mapa. Para isso, escreva:

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

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

## Criar um novo HashMap em Java

Para mostrar melhor o funcionamento do Hashmap em Java, apresentamos um caso prático: uma empresa deseja guardar uma lista de clientes que possa consultar a qualquer momento. É necessário, por um lado, o nome do cliente e, por outro, um número de cliente. Embora o número de cliente (que corresponde à chave) seja sempre único, em teoria poderia haver vários clientes com o mesmo nome (que seria armazenado como valor). O número é armazenado como **inteiro** e os nomes como **strings**. Em Java, o HashMap ficaria assim:

```java
import java.util.HashMap;
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	}
}
```

## Incluir elementos

Embora já tenha o HashMap do Java, ele está vazio. Para adicionar novos pares chave-valor, use o método **put()**. Veja o exemplo a seguir:

```java
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, "Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	System.out.println(kundenliste);
	}
}
```

Com o comando `System.out.println`, é impressa a lista de clientes:

```java
{1077=Manolo Rodríguez, 15312=Pepe García, 73329=María Pérez}
```

## Acesso aos elementos

Embora já exista uma lista de clientes à qual, teoricamente, podem ser adicionadas muitas mais entradas, também pode querer aceder a um cliente individual. Para tal, aplique o método **get()** à chave correspondente. Ficaria assim:

```java
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	System.out.println(lista de clientes.get(1077));
	}
}
```

Como resultado, apenas «Manolo Rodríguez» deve aparecer.

## Eliminar uma ou todas as entradas

Se desejar eliminar uma entrada específica, utilize o método **remove()**. Para colocá-lo em prática, siga o exemplo:

```java
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	lista de clientes.remove(1077);
	System.out.println(lista de clientes);
	}
}
```

Na consola, seria apresentado:

```java
{15312=Pepe García, 73329=María Pérez}
```

Como alternativa, também pode eliminar toda a lista. Para isso, utilize o método **clear()**. Veja como ele é aplicado no exemplo:

```java
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	kundenliste.clear();
	System.out.println(lista de clientes);
	}
}
```

Na consola, seria apresentado o seguinte:

```java
{ }
```

## Determinar o número de entradas

Embora o exemplo de HashMap em Java utilizado seja muito simples e, portanto, determinar o número de entradas não seja um problema, em projetos de maior porte, descobrir o número exato de entradas pode ser mais complicado. Para isso, pode-se recorrer ao método **size()**. Veja como ele é utilizado:

```java
public clase Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	System.out.println(lista de clientes.size());
	}
}
```

O número 3 seria exibido.

## Visualização de chaves ou valores isolados

Também é possível aceder a uma lista que contenha apenas chaves ou valores. Para isso, é necessário recorrer a um loop for-each. Utilize o método **keySet()** para as chaves e o método **values()** para os valores. Com este último, o código seria apresentado da seguinte forma:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	for (String i : lista de clientes.values()) {
		System.out.println(i);
		}
	}
}
```

Os seguintes resultados seriam apresentados:

```java
Manolo Rodríguez
Pepe García
María Pérez
```

## Verificar a disponibilidade de um item

Não só é possível aceder a uma entrada específica, como também é possível verificar se o HashMap do Java contém algum valor ou chave específicos. Para isso, utilizam-se os métodos **containsKey()** (para chaves) e **containsValue()** (para valores). Se o elemento estiver incluído, obtém-se «true». Se o elemento não estiver incluído, o resultado é «false». Na prática, os métodos são implementados como se mostra a seguir:

```java
public class Main {
public static void main(String[] args) {
	HashMap<Integer, String> lista de clientes = new HashMap<>();
	lista de clientes.put (1077, " Manolo Rodríguez");
	lista de clientes.put (15312, "Pepe García");
	lista de clientes.put (73329, "María Pérez");
	System.out.println(lista de clientes.containsKey(15312));
	System.out.println(lista de clientes.containsValue("Ana Martínez");
	}
}
```

Embora a chave «15312» apareça na lista, o valor «Ana Martínez» não aparece, pelo que a consola mostrará como resultado:

```java
true
false
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-hashmap/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-hashmap/) for AI/LLM consumption.