Java HashMap

Um HashMap em Java é uma parte da estrutura de coleções Java que implementa a interface Map. Ele é usado para armazenar pares de valores-chave e oferece desempenho em tempo constante para operações básicas, como adição, remoção e recuperação de elementos. O site HashMap é altamente eficiente e é comumente usado quando é necessária a associação exclusiva de chaves a valores.

Principais recursos

• Coleção não ordenada: HashMap não mantém nenhuma ordem para suas entradas.
• Permite valores nulos: Ele permite uma chave nula e vários valores nulos.
• Não sincronizado: HashMap não é seguro para threads. Para acesso simultâneo, considere o uso do site ConcurrentHashMap.

Uso

HashMap é ideal para cenários em que a recuperação, a inserção e a exclusão rápidas de elementos são necessárias. Ele é usado com frequência para armazenar dados em cache, gerenciar sessões de usuário e implementar dicionários.

Sintaxe

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

• KeyType: O tipo de dados das chaves.
• ValueType: O tipo de dados dos valores.
• mapName: O nome da instância do HashMap.

Exemplos

Exemplo 1: Operações básicas

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        
        // Adding elements
        map.put("Apple", 3);
        map.put("Banana", 5);
        map.put("Orange", 2);
        
        // Retrieving an element
        int count = map.get("Apple");
        System.out.println("Count of Apples: " + count);
        
        // Removing an element
        map.remove("Banana");
        
        // Checking if a key exists
        boolean hasOrange = map.containsKey("Orange");
        System.out.println("Contains Orange: " + hasOrange);
    }
}

Este exemplo demonstra operações básicas com um HashMap, incluindo adição, recuperação, remoção de elementos e verificação da existência de uma chave.

Exemplo 2: Iteração em um HashMap

import java.util.HashMap;
import java.util.Map;

public class HashMapIteration {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Dog", 1);
        map.put("Cat", 2);
        map.put("Bird", 3);
        
        // Iterating using entrySet
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

Este exemplo mostra como você pode iterar em um HashMap usando o método entrySet, que fornece acesso a chaves e valores.

Exemplo 3: Trabalhando com diferentes tipos de dados

import java.util.HashMap;

public class HashMapDifferentTypes {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        
        System.out.println("Value for key 1: " + map.get(1));
    }
}

Este exemplo demonstra um HashMap com chaves Integer e valores String.

Dicas e práticas recomendadas

• Capacidade inicial e fator de carga: Ao criar um HashMap, considere a possibilidade de especificar uma capacidade inicial e um fator de carga para otimizar o desempenho e reduzir o número de operações de rehash.

  HashMap map = new HashMap<>(16, 0.75f);

• Evite o redimensionamento frequente: Se o tamanho do site HashMap for conhecido antecipadamente, defina uma capacidade inicial adequada para evitar redimensionamentos frequentes, o que pode prejudicar o desempenho.
• Segurança da linha: Se você espera que vários threads acessem o HashMap simultaneamente, use Collections.synchronizedMap ou ConcurrentHashMap para garantir a segurança do thread.
• Use chaves imutáveis: Prefira usar objetos imutáveis como chaves para evitar problemas com a consistência do código hash e comportamentos inesperados.
• Manuseio de nulos: Seja cauteloso ao usar chaves ou valores nulos e certifique-se de que a lógica do aplicativo os considere.