HashMap é uma estrutura de dados dinâmica que armazena seus elementos na forma de par chave(K)/valor(V). Isso quer dizer que para cada chave há um valor associado.

Os elementos do HashMap são armazenados utilizando o tipo Map.Entry<K,V>. Para o uso do tipo Entry, a classe java.util.HashMap deve ser importada.

Na parte inicial vamos aprender algumas operaçoes básicas e mais adiante os métodos da classe java.util.HashMap.

Algumas características

1. Dinâmico
2. Heterogênea
3. Não ordenado
4. Implementa interface List
5. Acesso randômico a elementos
6. Não permite elemento repetido

Interfaces implementadas

1. Serializable
2. Cloneable
3. Map<K,V>

Para a utilização do tipo de dado HashMap, precisamos importar sua classe como na sintaxe abaixo:

Sintaxe

import java.util.HashMap;

O tipo de dado HashMap utiliza o conceito de Generics, e sua declaração é feita de acordo com a sintaxe abaixo:

Sintaxe

HashMap<K,V> nome_variavel = new HashMap<K,V>();  //vazio
HashMap<K,V> nome_variavel = new HashMap<K,V>(int initialCapacity); 
HashMap<K,V> nome_variavel = new = new HashMap<K,V>(Map map);

Onde

K: Tipo de dado para armazenar da chave.
V: Tipo de dado para armazenar o valor associado a chave
initialCapacity: capacidade inicial de elementos

Exemplo 1

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
	}
}

Saída

-

Novos elementos podem ser adicionados em um HashMap utilizando o método put como mostrado na sintaxe abaixo:

Sintaxe

public V put(K key, V value)

Onde

key: Chave
value: Valor

Retorno

Retorna elemento antigo

Se um elemento com a mesma key existir, seu valor será substituído por value.

Exemplo 2

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        System.out.println(hm);
	}
}

Saída

{20=Teste 20, 10=Teste 10}

Para ter acesso a um elemento de um HashMap, utilizamos o método get que recebe uma chave como argumento e retorna seu valor associado.

Sintaxe

public V get(Object key)

Onde

key: Valor da chave
V: Tipo de dado do valor associado a chave key.

Exemplo 3

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        //recuperando valor associado a chave 10
        System.out.println(hm.get(10));
	}
}

Saída

Teste 10

Para alterarmos o valor de um elemento em um HashMap, utilizamos o método put visto anteriormente.

Sintaxe

public V put(K key, V value)

Onde

E: tipo de dado referenciado.
index: índice de um elemento

Retorno

Retorno elemento antigo em index

Exemplo 4

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        
        System.out.println(hm);
        String vlAntigo = hm.put(10,"Teste 1000");
        System.out.println(vlAntigo);
        System.out.println(hm);
	}
}

Saída

777
888

A remoção de elementos de uma HashMap é feito por intermédio do método remove, com pode ser conferido na sintaxe abaixo:

Sintaxe

public V remove(Object key)

Onde

key: chave do elemento para remoção
V: Tipo de dado da chave

Exemplo 5

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor1");
        hm.put(3,"Valor1");
        
        System.out.println(hm);
        
        hm.remove(2);
        
        System.out.println(hm);
	}
}

Saída

{1=Valor1, 2=Valor1, 3=Valor1}
{1=Valor1, 3=Valor1}

Para termos conhecimento do número de elementos contido em uma HashMap, utilizamos o método size que retorna um inteiro contendo o número de elementos.

Sintaxe

public int size()

Exemplo 6

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor1");
        hm.put(3,"Valor1");
        
        System.out.println(hm.size());
	}
}

Saída

3

Para percorrermos um HashMap, utilizamos duas formas básicas utilizando o comando for, com auxílio dos métodos get ou o método forEach.

Para o uso do comando for, precisamos utilizar o tipo de dado Entry<K,V> que pertence a classe Map. Vamos utilizar também o método entrySet da classe HashMap.

Sintaxe

public void forEach(BiConsumer<? super E> action)
public Set<Map.Entry<K,V> entrySet()

O tipo de dado Entry possui os métodos getValue e getKey que retornam, respectivamente, o valor(V) e a chave(K) de um elemento de um HashMap.

Exemplo 7

//Main.java
import java.util.HashMap;
import java.util.Map;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        
        for( Map.Entry<Integer, String> e : hm.entrySet()){
            System.out.println(e.getKey());
            System.out.println(e.getValue());
        }
	}
}

Saída

20
Teste 20
10
Teste 10

Para melhor compreensão do exemplo abaixo, é necessário ter conhecimento sobre expressão lambda utilizada em conjunto com o método forEach.

Exemplo 8

//Main.java
import java.util.HashMap;
import java.util.Map;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        
        hm.forEach((c,v) ->{
            System.out.println(c);
            System.out.println(v);
        });
	}
}

Saída

123

Podemos utilizar o tipo de dado HashMap como parâmetro de um método assim como qualquer outro tipo de dados como foi visto em POO: Métodos.

Sintaxe

modificador_acesso HashMap<K,V> nome_metodo(HashMap<K,V> nome_parametro){
  //corpo
}

Onde

K: Tipo de dado para armazenar da chave.
V: Tipo de dado para armazenar o valor associado a chave

Exemplo 9

//Teste.java
import java.util.HashMap;
import java.util.Map;

public class Teste{
    
    public void metodo(HashMap<Integer,String> hm){
        
        for( Map.Entry<Integer, String> e : hm.entrySet()){
            System.out.println(e.getKey());
            System.out.println(e.getValue());
        }
    }
}

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        Teste t = new Teste();
        t.metodo(hm);
	}
}

Saída

20
Teste 20
10
Teste 10

A classe java.util.HashMap fornece métodos para manipular seus dados. Abaixo uma lista de todos os métodos dessa classe.

Para remover todos os elementos de um HashMap, podemos utilizar o método clear que não recebe nenhum argumento e não possui retorno.

Sintaxe

public void clear()

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm);
        
        hm.clear();
        
        System.out.println(hm); 
	}
}

Saída

{1=Valor1, 2=Valor2, 3=Valor3}
{}

Com o método containsKey, podemos verificar se uma chave já existe dentro de um HashMap. Esse método aceita uma chave como argumento.

Sintaxe

public boolean containsKey(Object key)

Onde

key: chave para verificar existência

Retorno

true se key está contida, false caso contrário

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm.containsKey(3));
	}
}

Saída

true

Com o método containsValue, podemos verificar se há alguma chave associada a um valor que é passado como argumento para o método.

Sintaxe

public boolean containsValue(Object value)

Onde

value: valor para verificar existência

Retorno

true se value está contida, false caso contrário

Exception

-

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm.containsValue("Valor3"));
	}
}

Saída

true

O método entrySet retorna uma coleção de todos elementos de um HashMap em um coleção Set.

Sintaxe

public Set<Map.Entry<K,V>> entrySet()

Onde

-

Retorno

Um Set contendo elementos chave-valor Map.Entry.

Exemplo

//Main.java
import java.util.HashMap;
import java.util.Map; //Map.Entry

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        for ( Map.Entry<Integer,String> el : hm.entrySet())
            System.out.println(el);
        }
}

Saída

1=Valor1
2=Valor2
3=Valor3

Com o método get podemos recuperar um elemento em um determinado local de um HashMap representado por uma chave que passada como argumento.

Sintaxe

public V get(Object key)

Onde

key: Valor da chave que desejamos recuperar
V: tipo de dado do elemento

Retorno

Valor associado a chave key

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm.get(3));
	}
}

Saída

Valor3

O método isEmpty é utilizados verificar se uma HashMap contem ou não elementos. Esse método não recebe argumentos e retorna um booleano.

Sintaxe

public boolean isEmpty()

Retorno

true se vazio, false caso contrário

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm.isEmpty());
	}
}

Saída

false

Com o método keySet podemos recuperar todas as chaves contidas em um HashMap em forma de uma coleção Set. Esse método não recebe argumentos.

Sintaxe

public Set<K> keySet()

Onde

 K: tipo de dado da chave

Retorno

Um coleção Set contendo todas as chaves

Exemplo

//Main.java
//Main.java
import java.util.HashMap;
import java.util.Map;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(10,"Teste 10");
        hm.put(20,"Teste 20");
        
        System.out.println(hm.keySet());
	}
}

Saída

[10,20]

Com o método put podemos adicionar um novo elemento em um HashMap. Esse método recebe uma chave e um valor como argumentos. Se a chave já existir, o valor associado à chave será atualizado.

Sintaxe

public V put(K key, V value)

Onde

key: chave do novo elemento ou elemento para alteração
value: valor para adição ou alteração

Retorno

Valor anterior. Null se key não existir

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");

        System.out.println(hm);

        hm.put(3,"Valor3");
        
        System.out.println(hm);
	}
}

Saída

{1=Valor1, 2=Valor2}
{1=Valor1, 2=Valor2, 3=Valor3}

A remoção de um elemento em uma determinada posição é feita utilizando o método remove que já foi visto nos exemplos iniciais sobre HashMap.

Sintaxe

public V remove(Object key)

Onde

key: chave do elemento para remoção

Retorno

Elemento removido. Null se key não existir

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor2");
        hm.put(3,"Valor3");
        
        System.out.println(hm);
        hm.remove(2);
        System.out.println(hm); 
	}
}

Saída

{1=Valor1, 2=Valor2, 3=Valor3}
{1=Valor1, 3=Valor3}

Com o método size podemos descobrir o número de elementos contidos em um HashMap. Esse método não recebe argumentos e retorna um inteiro.

Sintaxe

public int size()

Retorno

Inteiro contendo o número de elementos

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor1");
        hm.put(3,"Valor1");
        
        System.out.println(hm.size());
	}
}

Saída

3

Com o método values podemos recuperar todos os valores dos elementos de um HashMap. Esse método não recebe argumentos.

Sintaxe

public Collection<V> values()

Onde

V: tipo de dado dos valores associados as chaves

Retorno

Uma Collection contendo os valores contidos em um HashMap

Exemplo

//Main.java
import java.util.HashMap;

public class Main
{
	public static void main(String[] args) {
	    
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        
        hm.put(1,"Valor1");
        hm.put(2,"Valor1");
        hm.put(3,"Valor1");
        
        System.out.println(hm.values());
	}
}

Saída

[Valor1, Valor1, Valor1]

1. 24/07/2025 - revisão 4 - Correção em descrição de métodos; Ajustes: sintaxes, Tab.1 links movidos para métodos
2. 04/10/2024 - revisão 3 - Correção: 'containsValue', outras correções pontuais
3. 02/09/2024 - revisão 2 - Correção em links de values e put
5. 08/02/2024 - revisão 1 - correção em navegação e erros gramaticais
6. 04/09/2023 - versão inicial