Explorando funções em Java: Interface Map

Introdução

Neste artigo, iremos explorar o conceito de uma interface 'Map' em Java. Com uma abordagem voltada com exemplos simples, examinaremos como essa estrutura de dados pode ser aproveitada para enriquecer o desenvolvimento do seu software.

Figura ilustrativa da função `Map`

Oque é Interface Map?

É um objeto que mapeia valores para chaves, ou seja, através da chave consegue ser acessado o valor configurado, sendo que a chave não pode ser repetida ao contrário do valor, mas se caso tiver uma chave repetida é sobrescrito pela última chamada.

public interface Map<K,V>

//K - o tipo de chaves mantidas por este mapa
//V - o tipo de valores mapeados

• A interface Map fornece três visualizações de coleção, para que o conteúdo seja visto como um conjunto de chaves; conjunto de mapeamento de chave-valor.
• A ordem de um mapa é definida como a ordem na qual os iteradores na vizualização de coleção do mapa retornam seus elementos.

Nota: deve-se ter muito cuidado ao usar objetos mutáveis como chaves de mapas.

Todas as classes de implementação de mapas de propósito geral devem fornecer dois construtores "padrão". Um construtor vazio(sem argumento) que cria um mapa vazio e um construtor com um unico argumento do tipo Map, que cria um novo mapa com os mesmos mapeamentos de chave-valor que seu argumento.

// Construtor vazio        
Map<String, Integer> map1 = new HashMap<>();
  
// Construtor com um argumento do tipo Map
Map<String, Integer> map2 = new HashMap<>(map1);

Hierarquia

Figura ilustrativa hierarquia `HashMap`

Classes de implementação

Existem várias classes de implementação da interface `Map`em Java, cada uma com suas próprias caraterísticas e finalidades específicas. Algumas das classes mais comuns incluem:

• HashMap
• TreeMap
• LinkedHashMap
• HashTable
• ConcurrentHashMap
• EnumMap

Cada uma delas é adequada para diferentes cenários de uso, e a escolha correta depende dos requisitos do aplicativo em questão. Também podemos incluir as classes aninhadas e os métodos.

Exemplo com `HashMap`:

Oferece acesso rápido aos elementos, não garante nenhuma ordem específica dos elementos e permite chaves e valores nulos.

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


public class Main {
  public static void main(String[] args) {
      // Criando um HashMap
      Map<String, Integer> hashMap = new HashMap<>();


      // Adicionando elementos
      hashMap.put("Maçã", 10);
      hashMap.put("Banana", 20);
      hashMap.put("Laranja", 15);


      // Exibindo o mapa
      System.out.println("HashMap: " + hashMap);
  }
}

Output:

HashMap: {Maçã=10, Banana=20, Laranja=15}

Exemplo com `TreeMap`:

Mantém os elementos ordenados com base nas chaves e oferece um conjunto de métodos para navegar e manipular a estrutura da árvore.

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


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


      // Adicionando elementos
      treeMap.put("Maçã", 10);
      treeMap.put("Banana", 20);
      treeMap.put("Laranja", 15);


      // Exibindo o mapa
      System.out.println("TreeMap: " + treeMap);
  }
}

Output:

TreeMap: {Banana=20, Laranja=15, Maçã=10}

Exemplo com `LinkedHashMap`:

Mantém a ordem de inserção dos elementos e permite iteração em ordem de inserção ou acesso. Baseado em uma combinação de tabela de dispersão e lista duplamente ligada.

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


public class Main {
  public static void main(String[] args) {
      // Criando um LinkedHashMap
      Map<String, Integer> linkedHashMap = new LinkedHashMap<>();


      // Adicionando elementos
      linkedHashMap.put("Maçã", 10);
      linkedHashMap.put("Banana", 20);
      linkedHashMap.put("Laranja", 15);


      // Exibindo o mapa
      System.out.println("LinkedHashMap: " + linkedHashMap);
  }
}

Output:

LinkedHashMap: {Maçã=10, Banana=20, Laranja=15}

Classes Aninhadas

• Útil para entender quais classes estão relacionadas e encapsuladas dentre da classe principal.

• No caso da interface `Map`, a classe aninhada é `Map.Entry`, que representa um par de chave-valor em um mapa.

Resumo dos Métodos

Visão geral rápida dos métodos disponíveis.

• clear()
• put(K key, V value)
• get(Object key)
• containsKey(Object key)
• containsValue(Object value)
• isEmpty()
• size()
• remove(Object key)
• keySet()
• values()
• entrySet()

Esses são os principais métodos definidis na interface `Map`. Cada um deles desempenha um papel fundamental na manipulação e consulta de mapeamentos chave-valor em um mapa.

Referências: https://docs.oracle.com/javase/8/docs/api/java/util/Map.html