Java Map
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
Codigo usados no artigo
