Java Map

#Java

Um dos vários tipos de dados e um deles é o array associativo também conhecido com Map. O Map é uma estrutura de dados que associa chaves e valores únicos. O Map é muito útil na aplicação, principalmente quando precisamos buscar ou atualizar elementos por meio de sua chave.

O Map tem três classes principais, o HashMap, LinkedHashMap e TreeMap. Onde:

HashMap

Ele armazena os dados em pares Chave e Valor e não é thread-safe. Onde pode ser acessado por diferentes tipos de dados. Ele não aceita duplicadas caso tente inserir ele irar apenas substituir o valor. O HashMap não garante a ordem de criação, ou seja, ele armazena o valor sem se importar com a precedência deles.

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

public class Main
{
  public static void main(String[] args) {
         // Criando um HashMap com chave do tipo String e valor do tipo Integer
         Map<String, Integer> mapa = new HashMap<String, Integer>();


         // Adicionando elementos
         mapa.put("chave1", 10);
         mapa.put("chave2", 20);
         mapa.put("chave3", 30);
         mapa.put("chave1", 40); // Isso irá substituir o valor associado à chave 'chave1'
 
         
         System.out.println("Valor associado à chave 'chave1': " + mapa.get("chave1"));
         System.out.println("Valor associado à chave 'chave2': " + mapa.get("chave2"));
         System.out.println("Valor associado à chave 'chave3': " + mapa.get("chave3"));
 
         // Exibindo os elementos
         System.out.println("Elementos do HashMap:");
         for (String chave : mapa.keySet()) {
             System.out.println("Chave: " + chave + ", Valor: " + mapa.get(chave));
         }     
  }
}

Onde a saída é

Valor associado à chave 'chave1': 40
Valor associado à chave 'chave2': 20
Valor associado à chave 'chave3': 30
Elementos do HashMap:
Chave: chave2, Valor: 20
Chave: chave1, Valor: 40
Chave: chave3, Valor: 30

LinkedHashMap

O LinkedHashMap é uma variante do HashMap que mantém a ordem de inserção dos elementos. Ele mantém a ordem de inserção usando uma lista duplamente vinculada além da tabela hash para recuperar e armazenar dados, enquanto mantém uma lista duplamente vinculada de todas as suas entradas para preservar a ordem de inserção. Ou seja ao iterar sobre ele, os elementos são retornados na mesma ordem em que foram adicionados. oque pode ser necessário quando se precisa se manter a ordem dos elementos

import java.util.LinkedHashMap;
import java.util.Map;


public class Main {
  public static void main(String[] args) {

      Map<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();


      // Adicionando elementos
      linkedHashMap.put("chave1", 10);
      linkedHashMap.put("chave2", 20);
      linkedHashMap.put("chave3", 30);
      linkedHashMap.put("chave4", 40);


      // Exibindo os elementos 
      System.out.println("Elementos do LinkedHashMap:");
      for (String chave : linkedHashMap.keySet()) {
          System.out.println("Chave: " + chave + ", Valor: " + linkedHashMap.get(chave));
      }

  }
}

Onde a saída é:

Elementos do LinkedHashMap:
Chave: chave1, Valor: 10
Chave: chave2, Valor: 20
Chave: chave3, Valor: 30
Chave: chave4, Valor: 40

TreeMap

O TreeMap armazena pares chave-valor, onde a chave é armazenada em ordem natural crescente ou por meio de um comparador fornecido pelo usuário. oque oferece operações de busca e manipulação eficiente. O que é ótimo para aplicações que exigem acesso rápido aos elementos em ordem ordenada.

import java.util.Map;
import java.util.TreeMap;

public class Main {
  public static void main(String[] args) {
     
      Map<String, Integer> treeMap = new TreeMap<String, Integer>();


      // Adicionando elementos
      treeMap.put("chave3", 30);
      treeMap.put("chave1", 10);
      treeMap.put("chave4", 40);
      treeMap.put("chave2", 20);


      // Exibindo os elementos
      System.out.println("Elementos do TreeMap:");
      for (String chave : treeMap.keySet()) {
          System.out.println("Chave: " + chave + ", Valor: " + treeMap.get(chave));
      }
  }
}

Onde a saída é:

Elementos do TreeMap:
Chave: chave1, Valor: 10
Chave: chave2, Valor: 20
Chave: chave3, Valor: 30
Chave: chave4, Valor: 40

HashTable

A HashTable armazena os dados em chave-valor e é thread-safe. Onde pode ser acessado por diferentes tipos de dados. Ele não aceita duplicadas e caso for inserida, o valor correspondente será substituído. A HashTable não garante a ordem de criação, ou seja, ele armazena o valor sem se importar com a precedência deles. O uso do HashTable é desencorajada, pois ela é antiga e o Java introduziu outras implementações de mapas que são mais eficiente em ambientes de concorrentes.

import java.util.Hashtable;
import java.util.Map;

public class Main {
  public static void main(String[] args) {
      // Criando um Hashtable com chave do tipo String e valor do tipo Integer
      Hashtable<String, Integer> hashtable = new Hashtable<>();

      // Adicionando elementos
      hashtable.put("chave1", 10);
      hashtable.put("chave2", 20);
      hashtable.put("chave3", 30);
      hashtable.put("chave4", 40);

      // Exibindo os elementos do Hashtable
      System.out.println("Elementos do Hashtable:");
      for (Map.Entry<String, Integer> entry : hashtable.entrySet()) {
          System.out.println("Chave: " + entry.getKey() + ", Valor: " + entry.getValue());
      }
  }
}

Eficiência

HashMap : O acesso é eficiente geralmente O(1) , já que os valores são indexados por chave e também a sua eficiência em adicionar e remover deste que não haja colisões.

LinkedHashMap: O acesso é semelhante ao do HashMap porem sua adição e remoção é um pouco menos eficiente que o HashMap, pois mantém a ordem de inserção. No entanto, ainda é O(1).

TreeMap: O acesso, adição e remoção é eficiente geralmente O(log n) devido o processo de manter a ordem dos elementos e por ele ser mantido ordenados e organizados em uma estrutura de árvore.

HashTable: O acesso, adição e remoção é eficiente geralmente O(1) deste que não haja muitas colisões, já que pode haver algum overhead para garantir a segurança.

Caso De Uso

Um exemplo pratico do uso do Map poderia ser uma biblioteca onde pode ser pesquisado o adicionado um livro e exibir os livros disponíveis.

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


public class Biblioteca {
  private Map<String, Livro> catalogo;


  public Biblioteca() {
      this.catalogo = new HashMap<String, Livro>();
  }


  public void adicionarLivro(String titulo, Livro livro) {
      catalogo.put(titulo, livro);
  }


  public Livro buscarLivro(String titulo) {
      return catalogo.get(titulo);
  }


  public void exibirCatalogo() {
      System.out.println("Catálogo da Biblioteca:\n------------------------");
      for (Map.Entry<String, Livro> entry : catalogo.entrySet()) {
          System.out.println(entry.getKey() + ": " + entry.getValue());
          System.out.println("------------------------------");
      }
  }


  public static void main(String[] args) {
      Biblioteca biblioteca = new Biblioteca();


      // Adicionando livros
      biblioteca.adicionarLivro("A arte da guerra", new Livro("A arte da guerra", "Sun Tzu"));
      biblioteca.adicionarLivro("A princesa salva a si mesma neste livro", new Livro("A princesa salva a si mesma neste livro", "Amanda Lovelace"));
      biblioteca.adicionarLivro("A divina comedia - O inferno", new Livro("A divina comedia - O inferno", "Dante alighieri"));


      // Exibindo catálogo
      biblioteca.exibirCatalogo();


      // Buscando livro
      Livro livro = biblioteca.buscarLivro("A arte da guerra");
      if (livro != null) {
          System.out.println("Livro encontrado: " + livro);
      } else {
          System.out.println("Livro não encontrado.");
      }
  }
}


class Livro {
  private String titulo;
  private String autor;


  public Livro(String titulo, String autor) {
      this.titulo = titulo;
      this.autor = autor;
  }


  @Override
  public String toString() {
      return titulo + " por " + autor;
  }
}

Onde a saída seria :

Catálogo da Biblioteca:
------------------------
A arte da guerra: A arte da guerra por Sun Tzu
------------------------------
A princesa salva a si mesma neste livro: A princesa salva a si mesma neste livro por Amanda Lovelace
------------------------------
A divina comedia - O inferno: A divina comedia - O inferno por Dante alighieri
------------------------------
Livro encontrado: A arte da guerra por Sun Tzu

Conclusão

Em resumo o map é útil em várias ocasiões e tudo vai depender da compreensão de cada vantagem e desvantagem que cada um tem e qual se encaixa melhor no seu projeto, assim podendo otimizar o desempenho e a eficiência de sua aplicação Java.

Para saber mais, consulte a documentação do Java

Map (Java Platform SE 8 ) (oracle.com)

Ou para saber mais sobre o HashMap

Java HashMap (w3schools.com)

Codigo usados no artigo

LucasTalen/Desafio_Map_no_Java (github.com)