Interface Map Java

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

A interface Map do framework de coleções Java fornece funcionalidades da estrutura de dados Map.

ele implementa a interface Collection.

fluxo de trabalho do Map

No Java, os elementos Map são armazenados na chave/par de valores. A chave é o valor único associado a cada valor.

Conjunto Map não pode conter chaves repetidas. E cada chave está associada a um valor.

Podemos usar as chaves associadas para acessar e modificar os valores.

Na figura acima, temos valores: Estados Unidos, Brasil e Espanha. Todos temos chaves correspondentes: us, br e es.

Agora, podemos usar suas chaves correspondentes para acessar esses valores.

Atenção:Map interface mantém3conjuntos diferentes:

• Conjunto de chaves

• Conjunto de valores

• Chave/Conjunto de conjuntos de valores (conjunto Map).

Portanto, podemos acessar separadamente a chave, o valor e a associação.

Classes que implementam Map

Como Map é uma interface, não é possível criar objetos a partir dela.

Para usar as funcionalidades da interface Map, podemos usar as seguintes classes:

• HashMap

• EnumMap

• LinkedHashMap

• WeakHashMap

• TreeMap

Essas classes são definidas e implementadas na estrutura de coleções e implementam a interface Map.

Interfaces herdadas de Map

A interface Map também é herdada pelos seguintes subinterfaces:

• SortedMap

• NavigableMap

• ConcurrentMap

Como usar map?

No Java,我们必须导入 o pacote java.util.Map para usar Map. Após importar o pacote, crie o map conforme abaixo.

//Criar Map usando a classe HashMap
Map<Key, Value> numbers = new HashMap<>();

No código acima, criamos um Map chamado numbers. Usamos a classe HashMap para implementar a interface Map.

Aqui,

• Key - Identificador único usado para associar cada elemento (valor) no map

• Value - elementos associados ao map pelo chave

métodos map

A interface Map inclui todos os métodos da interface Collection. Isso porque Collection é a superinterface do Map.

Além dos métodos disponíveis na interface Collection, a interface Map inclui os seguintes métodos:

• put(K, V) - Inserir a associação entre a chave K e o valor V no map. Se a chave já existir, o novo valor substituirá o valor antigo.

• putAll() - Inserir todos os itens do conjunto Map especificado neste Map.

• putIfAbsent(K, V) - Inserir a associação entre a chave K e o valor V se a chave K não estiver associada a um valor.

• get(K) - Retornar o valor associado à chave K especificada. Se a chave não for encontrada, retornar null.

• getOrDefault(K, defaultValue) - Retornar o valor associado à chave K especificada. Se a chave não for encontrada, retornar defaultValue.

• containsKey(K) - Verificar se a chave especificada K está no map.

• containsValue(V) - Verificar se o valor especificado V existe no map.

• replace(K, V) - Substituir o valor da chave K pelo novo valor especificado V.

• replace(K, oldValue, newValue) - Substituir o valor da chave K pelo novo valor newValue apenas quando a chave K estiver associada ao valor oldValue.

• remove(K) - Remover o item do Map representado pela chave K.

• remove(K, V) - Remover o item associado à chave K e ao valor V do conjunto Map.

• keySet() -Retorna o conjunto de todas as chaves existentes no Map.

• values() -Retorna um conjunto que contém todos os valores contidos no conjunto Map.

• entrySet() -Retorna todas as chaves existentes no map/conjunto de mapeamento de valores.

implementação da interface map

1.implementar a classe HashMap

import java.util.Map;
import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Usando a classe HashMap para criar map
　　　　　　　　Map<String, Integer> numbers = new HashMap<>();
　　　　　　　　//inserir elementos no conjunto do map
　　　　　　　　numbers.put("One",　1});
　　　　　　　　numbers.put("Two",　2});
　　　　　　　　System.out.println("Map: ")　+　numbers);
　　　　　　　　//chaves do map
　　　　　　　　System.out.println("Keys: ")　+　numbers.keySet());
　　　　　　　　//valores do map
　　　　　　　　System.out.println("Values: ")　+　numbers.values());
　　　　　　　　//entradas do map
　　　　　　　　System.out.println("Entries: ")　+　numbers.entrySet());
　　　　　　　　//Remover elemento do conjunto de mapas
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("O valor removido é: ")　+　value);
　　　　}
}

Resultados de Saída

Map: {One=1, Two=2}
Keys: [One, Two]
Values: [1,　2]
Entries: [One=1, Two=2]
O valor removido é:　2

Para obter mais informações sobre HashMap, acesseHashMap Java.

2.implementar a classe TreeMap

import java.util.Map;
import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Usando TreeMap para criar map
　　　　　　　　Map<String, Integer> values = new TreeMap<>();
　　　　　　　　//inserir elemento no map
　　　　　　　　values.put("Second",　2});
　　　　　　　　values.put("First",　1});
　　　　　　　　System.out.println("Usando TreeMap para criar map: "　+　values);
　　　　　　　　//substituir valor
　　　　　　　　values.replace("First",　11});
　　　　　　　　values.replace("Second",　22});
　　　　　　　　System.out.println("Novo Map: ");　+　values);
　　　　　　　　//Remover elemento do conjunto de mapas
　　　　　　　　int removedValue = values.remove("Primeiro");
　　　　　　　　System.out.println("Valor removido: ");　+　removedValue);
　　　　}
}

Resultados de Saída

Criar map com TreeMap: {Primeiro =1, Segundo =2}
Novo Map: {Primeiro =11, Segundo =22}
Valor removido:　11

Para obter mais informações sobre TreeMap, acesseJava TreeMap.