A interface Map presente no pacote java.util representa um mapeamento entre uma chave e um valor. A interface Map não é um subtipo da interface Collection . Portanto, ele se comporta de maneira um pouco diferente do resto dos tipos de coleção. Um mapa contém chaves exclusivas.

Exemplo:

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class HashMapDemo {
    public static void main(String args[])
    {
        Map<String, Integer> hm
            = new HashMap<String, Integer>();
  
        hm.put("a", new Integer(100));
        hm.put("b", new Integer(200));
        hm.put("c", new Integer(300));
        hm.put("d", new Integer(400));
  
        // Traversing through the map
        for (Map.Entry<String, Integer> me : hm.entrySet()) {
            System.out.print(me.getKey() + ":");
            System.out.println(me.getValue());
        }
    }
}

a: 100
b: 200
c: 300
d: 400

Execução de várias operações usando Interface de Mapa e Classe HashMap

Como Map é uma interface, ele pode ser usado apenas com uma classe que implementa essa interface. Agora, vamos ver como realizar algumas operações usadas com frequência em um mapa usando a classe HashMap amplamente usada . E também, após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no mapa.

1. Adicionando Elementos: Para adicionar um elemento ao mapa, podemos usar o método put() . No entanto, o pedido de inserção não é retido no hashmap. Internamente, para cada elemento, um hash separado é gerado e os elementos são indexados com base nesse hash para torná-lo mais eficiente.

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Default Initialization of a
        // Map
        Map<Integer, String> hm1 = new HashMap<>();
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm2
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(1, "Geeks");
        hm1.put(2, "For");
        hm1.put(3, "Geeks");
  
        hm2.put(new Integer(1), "Geeks");
        hm2.put(new Integer(2), "For");
        hm2.put(new Integer(3), "Geeks");
  
        System.out.println(hm1);
        System.out.println(hm2);
    }
}

{1 = Geeks, 2 = For, 3 = Geeks}
{1 = Geeks, 2 = For, 3 = Geeks}

2. Alterando Elementos: Depois de adicionar os elementos, se desejarmos alterar o elemento, isso pode ser feito adicionando novamente o elemento com o método put(). Uma vez que os elementos no mapa são indexados usando as chaves, o valor da chave pode ser alterado simplesmente inserindo o valor atualizado para a chave que desejamos alterar.

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "Geeks");
        hm1.put(new Integer(3), "Geeks");
  
        System.out.println("Initial Map " + hm1);
  
        hm1.put(new Integer(2), "For");
  
        System.out.println("Updated Map " + hm1);
    }
}

Mapa inicial {1 = Geeks, 2 = Geeks, 3 = Geeks}
Mapa atualizado {1 = Geeks, 2 = For, 3 = Geeks}

3. Removendo Elemento: Para remover um elemento do Mapa, podemos usar o método remove() . Este método pega o valor da chave e remove o mapeamento de uma chave deste mapa, se estiver presente no mapa.

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
  
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
        hm1.put(new Integer(4), "For");
  
        // Initial Map
        System.out.println(hm1);
  
        hm1.remove(new Integer(4));
  
        // Final Map
        System.out.println(hm1);
    }
}

{1 = Geeks, 2 = For, 3 = Geeks, 4 = For}
{1 = Geeks, 2 = For, 3 = Geeks}

4. Iterando pelo Mapa: Existem várias maneiras de iterar pelo Mapa. A maneira mais famosa é usar um loop for-each e obter as chaves. O valor da chave é encontrado usando o método getValue().

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
  
        for (Map.Entry mapElement : hm1.entrySet()) {
            int key
                = (int)mapElement.getKey();
  
            // Finding the value
            String value
                = (String)mapElement.getValue();
  
            System.out.println(key + " : "
                               + value);
        }
    }
}

1: Geeks
2: para
3: Geeks

Características de uma interface de mapa

1. Um mapa não pode conter chaves duplicadas e cada chave pode ser mapeada para no máximo um valor. Algumas implementações permitem chave nula e valor nulo como o HashMap e LinkedHashMap , mas algumas não gostam do TreeMap .
2. A ordem de um mapa depende das implementações específicas. Por exemplo, TreeMap e LinkedHashMap têm ordem previsível, enquanto o HashMap não.
3. Existem duas interfaces para implementar Map em java. Eles são, Map e SortedMap , e três classes: HashMap, TreeMap e LinkedHashMap.

Por que e quando usar o Maps?

Os mapas são perfeitos para usar no mapeamento de associação de valores-chave, como dicionários. Os mapas são usados ​​para realizar pesquisas por chaves ou quando alguém deseja recuperar e atualizar elementos por chaves. Alguns exemplos são:

• Um mapa de códigos de erro e suas descrições.
• Um mapa de códigos postais e cidades.
• Um mapa de gerentes e funcionários. Cada gerente (chave) é associado a uma lista de funcionários (valor) que ele gerencia.
• Um mapa de turmas e alunos. Cada classe (chave) está associada a uma lista de alunos (valor).

Criação de objetos de mapa

Como Map é uma interface , os objetos não podem ser criados do tipo map. Sempre precisamos de uma classe que estenda esse mapa para criar um objeto. E também, após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no Mapa. Este mapa de tipo seguro pode ser definido como:

// Obj é o tipo de objeto a ser armazenado no mapa do
mapa<obj obj=""> hm = novo HashMap<obj obj="">();</obj></obj>

Classes que implementam a interface do mapa

1. HashMap: HashMap é uma parte da coleção do Java desde o Java 1.2. Ele fornece a implementação básica da interface Map do Java. Ele armazena os dados em pares (chave, valor). Para acessar um valor, é preciso conhecer sua chave. Esta classe usa uma técnica chamada Hashing . Hashing é uma técnica de converter uma string grande em uma string pequena que representa a mesma string. Um valor mais curto ajuda na indexação e pesquisas mais rápidas. Vamos ver como criar um objeto de mapa usando esta classe.

// Java Program to illustrate the Hashmap Class
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
        Map<String, Integer> map
            = new HashMap<>();
  
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        for (Map.Entry<String, Integer> e : map.entrySet())
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

vaibhav 20
Vishal 10
sachin 30

2. LinkedHashMap: LinkedHashMap é como o HashMap, com um recurso adicional de manter uma ordem dos elementos inseridos nele. O HashMap oferece a vantagem de inserção, pesquisa e exclusão rápidas, mas nunca mantém o rastreamento e a ordem de inserção que o LinkedHashMap fornece, onde os elementos podem ser acessados ​​em seu pedido de inserção. Vamos ver como criar um objeto de mapa usando esta classe.

// Java Program to illustrate the LinkedHashmap Class
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
        Map<String, Integer> map
            = new LinkedHashMap<>();
  
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        for (Map.Entry<String, Integer> e : map.entrySet())
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

Vishal 10
sachin 30
vaibhav 20

3. TreeMap : O TreeMap em Java é usado para implementar a interface Map e NavigableMap junto com a classe abstrata. O mapa é classificado de acordo com a ordem natural de suas chaves ou por um Comparador fornecido no momento da criação do mapa, dependendo de qual construtor é usado. Isso prova ser uma maneira eficiente de classificar e armazenar os pares de valores-chave. A ordem de armazenamento mantida pelo mapa de árvore deve ser consistente com iguais, assim como qualquer outro mapa classificado, independentemente dos comparadores explícitos. Vamos ver como criar um objeto de mapa usando esta classe.

// Java Program to illustrate the Treemap Class
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
        Map<String, Integer> map
            = new TreeMap<>();
  
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        for (Map.Entry<String, Integer> e : map.entrySet())
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

sachin 30
vaibhav 20
Vishal 10

Métodos na interface do mapa