Interfaccia Map Java

In questo tutorial, impareremo l'interfaccia Java Map e i suoi metodi.

L'interfaccia Map del framework delle raccolte Java fornisce le funzionalità della struttura dati Map.

Implementa l'interfaccia Collection.

Flusso di lavoro di map

In Java, gli elementi Map sono memorizzati in coppie chiave/valore. La chiave è un valore unico associato a ciascun valore.

Le raccolte Map non possono contenere chiavi ripetute e ogni chiave è associata a un valore.

Possiamo accedere e modificare i valori utilizzando le chiavi associate.

Nell'immagine precedente, abbiamo i valori: Stati Uniti, Brasile e Spagna. Ognuno di essi ha una chiave corrispondente: us, br e es.

Ora possiamo accedere a questi valori utilizzando le chiavi corrispondenti.

Attenzione:L'interfaccia Map mantiene tre set diversi:

• Set di chiavi

• Set di valori

• Set di associazioni chiave/valore (insieme Map).

Di conseguenza, possiamo accedere rispettivamente alle chiavi, ai valori e alle associazioni.

Classi che implementano Map

Poiché Map è un'interfaccia, non è possibile creare oggetti da essa.

Per utilizzare le funzionalità dell'interfaccia Map, possiamo utilizzare le seguenti classi:

• HashMap

• EnumMap

• LinkedHashMap

• WeakHashMap

• TreeMap

WeakHashMap

TreeMap

Queste classi sono definite e implementate nella struttura delle collection e implementano l'interfaccia Map.

• Interfaccia derivata da Map

• L'interfaccia Map è ereditata anche da questi sottointerfacci:

• SortedMap

NavigableMap

ConcurrentMap

Come utilizzare la mappa?
// Creazione di una mappa utilizzando la classe HashMap

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

Nel codice sopra, abbiamo creato una mappa chiamata numbers. Abbiamo implementato l'interfaccia Map utilizzando la classe HashMap.

• qui,

• Key - identificatore unico utilizzato per associare ogni elemento (valore) nella mappa

Value - elemento associato alla chiave nella mappa

Metodi di mappa

Oltre ai metodi disponibili nell'interfaccia Collection, l'interfaccia Map include anche i seguenti metodi:

• put(K,V) - Inserisce l'associazione tra la chiave K e il valore V nella mappa. Se la chiave esiste già, il nuovo valore sostituirà il vecchio valore.

• putAll() - Inserisce tutti gli elementi dell'insieme di mappe specificato nel questo insieme di mappe.

• putIfAbsent(K,V) - Inserisce l'associazione tra la chiave K e il valore V se la chiave K non è ancora associata a un valore.

• get(K) - Restituisce il valore associato alla chiave specificata K. Se la chiave non viene trovata, viene restituito null.

• getOrDefault(K,defaultValue) - Restituisce il valore associato alla chiave specificata K. Se la chiave non viene trovata, viene restituito defaultValue.

• containsKey(K） - Controlla se la chiave specificata K esiste nella mappa.

• containsValue(V) - Controlla se il valore specificato V esiste nella mappa.

• replace(K,V) - Sostituisce il valore associato alla chiave K con un nuovo valore specificato V.

• replace(K,oldValue,newValue) - Sostituisce il valore associato alla chiave K con un nuovo valore newValue solo se il valore attuale è oldValue.

• remove(K) - Elimina l'elemento dalla mappa rappresentato dalla chiave K.

• remove(K,V) - Elimina l'elemento associato alla chiave K e al valore V dalla mappa.

• keySet() - Restituisce un insieme di tutte le chiavi esistenti nella mappa.

• values() - Restituisce un insieme di valori contenuti in una mappa.

• entrySet() - restituisce l'insieme di tutte le mappe chiave/valore esistenti nella mappa.

Implementazione dell'interfaccia Map

1. Implementazione della classe HashMap

import java.util.Map;
import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// creazione di map con HashMap
　　　　　　　　Map<String, Integer> numbers = new HashMap<>();
　　　　　　　　// inserisci l'elemento nella collezione della mappa
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　System.out.println("Map: " + numbers);
　　　　　　　　// chiavi della mappa
　　　　　　　　System.out.println("Keys: " + numbers.keySet());
　　　　　　　　// valori della mappa
　　　　　　　　System.out.println("Values: " + numbers.values());
　　　　　　　　// elenco delle voci della mappa
　　　　　　　　System.out.println("Entries: " + numbers.entrySet());
　　　　　　　　//Eliminare l'elemento dalla collezione map
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Il valore eliminato è: " + value);
　　　　}
}

Risultato di output

Map: {One=1, Two=2}
Keys: [One, Two]
Values: [1, 2]
Entries: [One=1, Two=2]
Il valore eliminato è: 2

Per ulteriori informazioni su HashMap, visitaHashMap Java.

2. Implementazione della classe TreeMap

import java.util.Map;
import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// creazione di map con TreeMap
　　　　　　　　Map<String, Integer> values = new TreeMap<>();
　　　　　　　　// inserisci l'elemento nella mappa
　　　　　　　　values.put("Second", 2);
　　　　　　　　values.put("First", 1);
　　　　　　　　System.out.println("Creazione di map con TreeMap: " + values);
　　　　　　　　// sostituisci il valore
　　　　　　　　values.replace("First", 11);
　　　　　　　　values.replace("Second", 22);
　　　　　　　　System.out.println("Nuovo Map: " + values)}
　　　　　　　　//Eliminare l'elemento dalla collezione map
　　　　　　　　int removedValue = values.remove("First");
　　　　　　　　System.out.println("Valore rimosso: " + removedValue);
　　　　}
}

Risultato di output

Creare map con TreeMap: {First=1, Second=2}
Nuovo Map: {First=11, Second=22}
Valore rimosso: 11

Per ulteriori informazioni su TreeMap, visitareJava TreeMap.