Interface de mapa Java

Neste tutorial, aprenderemos sobre a interface Java Map e seus métodos.

O Map A interface da estrutura de coleções Java fornece a funcionalidade da estrutura de dados do mapa.

Trabalho do Mapa

Em Java, elementos de Map são armazenados em chave/valor pares. Chaves são valores únicos associados a Valores individuais .

Um mapa não pode conter chaves duplicadas. E cada chave está associada a um único valor.

Podemos acessar e modificar valores usando as chaves associadas a eles.

No diagrama acima, temos os valores:Estados Unidos , Brasil , e Espanha . E temos as chaves correspondentes:us , br e es .

Agora, podemos acessar esses valores usando suas chaves correspondentes.

Observação: O Map interface mantém 3 conjuntos diferentes:

o conjunto de chaves
o conjunto de valores
o conjunto de associações de chave/valor (mapeamento).

Assim, podemos acessar chaves, valores e associações individualmente.

Classes que implementam Map

Desde Map é uma interface, não podemos criar objetos a partir dela.

Para usar as funcionalidades do Map interface, podemos usar estas classes:

HashMap
EnumMap
LinkedHashMap
WeakHashMap
Mapa de árvore

Essas classes são definidas no framework de coleções e implementam o Map interface.

Interfaces que estendem o mapa

O Map interface também é estendida por estas subinterfaces:

Mapa Classificado
Mapa navegável
Mapa Concorrente

Como usar o Mapa?

Em Java, devemos importar o java.util.Map pacote para usar Map . Depois de importar o pacote, veja como podemos criar um mapa.

// Map implementation using HashMap
Map<Key, Value> numbers = new HashMap<>();

No código acima, criamos um Map chamados números . Usamos o HashMap classe para implementar o Map interface.

Aqui,

Chave - um identificador único usado para associar cada elemento (valor) em um mapa
Valor - elementos associados por chaves em um mapa

Métodos de Mapa

O Map interface inclui todos os métodos do Collection interface. É porque Collection é uma super interface de Map .

Além dos métodos disponíveis no Collection interface, o Map interface também inclui os seguintes métodos:

put(K, V) - Insere a associação de uma chave K e um valor V no mapa. Se a chave já estiver presente, o novo valor substituirá o valor antigo.
putAll() - Insere todas as entradas do mapa especificado neste mapa.
putIfAbsent(K, V) - Insere a associação se a chave K ainda não está associado ao valor V .
obter(K) - Retorna o valor associado à chave especificada K . Se a chave não for encontrada, ela retornará null .
getOrDefault(K, defaultValue) - Retorna o valor associado à chave especificada K . Se a chave não for encontrada, ela retornará o defaultValue .
contémKey(K) - Verifica se a chave especificada K está presente no mapa ou não.
contémValue(V) - Verifica se o valor especificado V está presente no mapa ou não.
substituir(K, V) - Substitua o valor da chave K com o novo valor especificado V .
substituir(K, valor antigo, valor novo) - Substitui o valor da chave K com o novo valor newValue somente se a chave K está associado ao valor oldValue .
remover(K) - Remove a entrada do mapa representada pela chave K .
remover(K, V) - Remove a entrada do mapa que possui a chave K associado ao valor V .
conjunto de chaves() - Retorna um conjunto de todas as chaves presentes em um mapa.
valores() - Retorna um conjunto de todos os valores presentes em um mapa.
entrySet() - Retorna um conjunto de todos os mapeamentos de chave/valor presentes em um mapa.

Implementação da interface do mapa

1. Implementando a classe HashMap

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

class Main {

    public static void main(String[] args) {
        // Creating a map using the HashMap
        Map<String, Integer> numbers = new HashMap<>();

        // Insert elements to the map
        numbers.put("One", 1);
        numbers.put("Two", 2);
        System.out.println("Map: " + numbers);

        // Access keys of the map
        System.out.println("Keys: " + numbers.keySet());

        // Access values of the map
        System.out.println("Values: " + numbers.values());

        // Access entries of the map
        System.out.println("Entries: " + numbers.entrySet());

        // Remove Elements from the map
        int value = numbers.remove("Two");
        System.out.println("Removed Value: " + value);
    }
}

Saída

Map: {One=1, Two=2}
Keys: [One, Two]
Values: [1, 2]
Entries: [One=1, Two=2]
Removed Value: 2

Para saber mais sobre HashMap , visite Java HashMap.

2. Implementando a classe TreeMap

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

class Main {

    public static void main(String[] args) {
        // Creating Map using TreeMap
        Map<String, Integer> values = new TreeMap<>();

        // Insert elements to map
        values.put("Second", 2);
        values.put("First", 1);
        System.out.println("Map using TreeMap: " + values);

        // Replacing the values
        values.replace("First", 11);
        values.replace("Second", 22);
        System.out.println("New Map: " + values);

        // Remove elements from the map
        int removedValue = values.remove("First");
        System.out.println("Removed Value: " + removedValue);
    }
}

Saída

Map using TreeMap: {First=1, Second=2}
New Map: {First=11, Second=22}
Removed Value: 11

Para saber mais sobre TreeMap , visite Java TreeMap.

Java LinkedBlockingQueue Java HashMap

Java