java map interface tutorial with implementation examples
Questo tutorial completo su Java Map spiega come creare, inizializzare e iterare attraverso le mappe. Imparerai anche i metodi delle mappe e gli esempi di implementazione:
Imparerai le basi dell'interfaccia della mappa, i metodi supportati dall'interfaccia della mappa e altri termini specifici relativi all'interfaccia della mappa.
La raccolta di mappe in Java è una raccolta che mappa una chiave su un valore. È una raccolta composta da chiavi e valori. Ogni voce nella mappa è costituita da una chiave con il valore corrispondente. Le chiavi sono uniche nelle mappe. Le mappe possono essere utilizzate in genere quando è necessario modificare una raccolta in base a un valore chiave.
=> Controlla TUTTI i tutorial Java qui.
Cosa imparerai:
- Mappe in Java
- Metodi mappa
- Implementazione di Java Map
- Conclusione
Mappe in Java
La mappa in Java fa parte dell'interfaccia java.util.map. L'interfaccia della mappa non fa parte dell'interfaccia della raccolta e questo è il motivo per cui le mappe sono diverse dalle altre raccolte.
La gerarchia generale dell'interfaccia della mappa è mostrata di seguito.
Come mostrato sopra, ci sono due interfacce per implementare la mappa, ovvero l'interfaccia della mappa e l'interfaccia SortMap. Esistono tre classi, ovvero HashMap, TreeMap e LinkedHashMap.
Questi tipi di mappa sono descritti di seguito:
| Classe | Descrizione | |
|---|---|---|
| rimuovere | V remove (Object key) | Elimina una voce della mappa per la chiave specificata |
| LinkedHashMap | Si estende dalla classe HashMap. Questa mappa mantiene l'ordine di inserzione | |
| HashMap | Implementa un'interfaccia mappa. Nessun ordine viene mantenuto da HashMap. | |
| TreeMap | Implementa sia l'interfaccia map sia quella SortMap. TreeMap mantiene un ordine crescente. |
Punti da ricordare sulle mappe.
- Nelle mappe, ogni chiave può mappare al massimo un valore. Inoltre, non possono essere presenti chiavi duplicate nelle mappe.
- Le implementazioni di mappe come HashMap e LinkedHashMap consentono chiavi e valori null. Tuttavia, TreeMap non lo consente.
- Una mappa non può essere attraversata così com'è. Quindi per l'attraversamento, deve essere convertito in set utilizzando il metodo keyset () o entrySet ().
Crea una mappa in Java
Per creare una mappa in Java, prima dobbiamo includere l'interfaccia nel nostro programma. Possiamo utilizzare una delle seguenti istruzioni nel programma per importare la funzionalità della mappa.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Dobbiamo istanziare un'implementazione concreta della mappa in quanto è un'interfaccia.
Le seguenti istruzioni creano una mappa in Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Le istruzioni precedenti creeranno mappe con specifiche predefinite.
Possiamo anche creare mappe generiche specificando i tipi sia per la chiave che per il valore.
Map myMap = new HashMap(); La definizione precedente avrà chiavi di tipo stringa e oggetti come valori.
Inizializza una mappa in Java
Può essere inizializzato utilizzando i seguenti metodi:
# 1) Utilizzo delle raccolte
La classe Java Collections dispone di metodi factory che possono essere utilizzati per inizializzare le raccolte incluse le mappe.
Alcuni metodi utilizzati per inizializzare la mappa sono i seguenti:
(1) Collections.EmptyMap ()
Collections.EmptyMap () restituisce una mappa serializzabile e immutabile che è vuota. Per esempio, la seguente riga di codice,
Map myMap = Collections.EMPTY_MAP; Questo creerà una mappa vuota. Il metodo precedente può generare un 'avviso di assegnazione non controllata' e quindi possiamo anche utilizzare il modulo indipendente dai tipi come segue.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
Il metodo unModifiableMap () accetta un'altra mappa come argomento e crea una vista non modificabile della mappa originale.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
La classe Collections fornisce anche un metodo factory 'singletonMap ()' che crea una mappa singleton immutabile con una sola voce.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Utilizzo di Java 8
Possiamo ottenere un flusso di dati dai metodi API Java 8 stream e costruire mappe utilizzando i servizi di raccolta.
Alcuni dei metodi per costruire le mappe sono:
(1) Collectors.toMap ()
Raccogliamo un flusso e quindi utilizziamo il metodo Collectors.toMap () per costruire una mappa.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); L'istruzione precedente crea una mappa dal flusso Java 8.
(2) Collectors.collectingAndThen ()
In questo, adattiamo il metodo toMap () che consente al raccoglitore di produrre una mappa immutabile utilizzando il metodo collectAndThen ().
Map immutableMap = Stream.of(new String()(){ {'USA', 'Washington'}, {'United Kingdom', 'London”} }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)), Collections::unmodifiableMap)); # 3) Utilizzando il metodo put dell'interfaccia della mappa
Il metodo put () dell'interfaccia della mappa può essere utilizzato per assegnare i valori iniziali alle mappe.
# 4) Utilizzo dell'inizializzazione del doppio rinforzo
La tecnica 'inizializzazione doppia parentesi graffa' crea una classe interna. Questa classe è anonima e contiene un inizializzatore di istanza. Questa non è una tecnica preferita e dovrebbe essere evitata in quanto potrebbe causare perdite di memoria o problemi di serializzazione.
Il programma seguente mostra i vari metodi di inizializzazione di una mappa discussi sopra.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('
singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('
map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('
capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('
Map values:' + country_map); } }Produzione:
Valori mappa mappa non modificabili: {}
singleton_map Mappa valori: {10 = TEN}
Valori map_cities: {CH = Chennai, DL = New Delhi, MH = Mumbai}
valori capitals_Map: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Valori mappa: {USA = Washington, GER = Berlino, UK = Londra, IND = Delhi}
Iterare sulla mappa in Java e stampare la mappa
Possiamo attraversare la mappa proprio nello stesso modo in cui attraversiamo le altre raccolte. Oltre ad attraversare le voci della mappa, possiamo anche attraversare solo le chiavi o solo i valori nella mappa. Si noti che per attraversare una mappa, è necessario prima convertirla in set.
I seguenti metodi vengono utilizzati per attraversare le voci della mappa.
Utilizzo di Entry Iterator
In questo metodo, otteniamo un iteratore di voci da un insieme di voci. Quindi, utilizzando i metodi getKey e getValue, recuperiamo la coppia chiave-valore per ciascuna voce della mappa.
Il seguente programma mostra l'utilizzo di un iteratore di immissione.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Produzione:
Le voci della mappa sono:
VALORE CHIAVE
CH Chennai
DL New Delhi
MH Mumbai
Nel programma sopra, otteniamo un iteratore di ingresso dalla mappa utilizzando il metodo entrySet. Quindi attraversiamo la mappa utilizzando il metodo hasNext () dell'iteratore di immissione e stampiamo la coppia chiave-valore.
Utilizzo di una voce per ogni ciclo
Qui attraversiamo l'entrySet usando il ciclo for-each e l'implementazione è mostrata di seguito.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Produzione:
Le voci della mappa sono:
VALORE CHIAVE
CH Chennai
DL New Delhi
MH Mumbai
Metodi mappa
L'interfaccia della mappa in Java supporta varie operazioni simili a quelle supportate da altre raccolte. In questa sezione, discuteremo i vari metodi forniti da Map API in Java. Poiché lo scopo di questo tutorial è limitato all'introduzione di un'interfaccia mappa in generale, non descriveremo questi metodi.
Discuteremo questi metodi in dettaglio mentre discuteremo delle classi dell'interfaccia della mappa.
La tabella seguente elenca tutti i metodi forniti dall'API map.
| Nome metodo | Metodo Prototipo | Descrizione |
|---|---|---|
| ottenere | V get (Object key) | Restituisce l'oggetto o il valore per la chiave data |
| mettere | V put (chiave oggetto, valore oggetto) | Inserisci la voce valore-chiave nella mappa |
| metti tutto | void putAll (Mappa mappa) | Inserisci le voci della mappa nella mappa. In altre parole, copia o clona una mappa. |
| mazzo di chiavi | Imposta keySet () | Restituisce la visualizzazione impostata della mappa. |
| entrySet | Impostato | I ritorni impostano la visualizzazione per una data mappa |
| valori | Valori di raccolta () | Restituisce la vista della raccolta dei valori nella mappa. |
| taglia | int size () | Restituisce il numero di voci nella mappa |
| chiaro | void clear () | Cancella la mappa |
| è vuoto | booleano isEmpty () | Controlla se la mappa è vuota e restituisce true in caso affermativo. |
| contieneValore | boolean containsValue (valore oggetto) | Restituisce vero se la mappa contiene il valore uguale al valore dato |
| contieneKey | booleano containsKey (chiave oggetto) | Restituisce vero se una determinata chiave esiste nella mappa |
| è uguale a | booleano è uguale a (Oggetto o) | Confronta l'oggetto specificato o con la mappa |
| codice hash | int hashCode () | restituisce il codice hash per la mappa |
| per ciascuno | void forEach (azione BiConsumer) | Esegue una determinata azione per ogni voce nella mappa |
| getOrDefault | V getOrDefault (Object key, V defaultValue) | Restituisce il valore specificato per la chiave data o il suo valore predefinito se la chiave non è presente |
| rimuovere | booleano remove (chiave oggetto, valore oggetto) | Rimuove le chiavi e i valori specificati |
| sostituire | V sostituire (tasto K, valore V) | Sostituisce la chiave data con il valore specificato |
| sostituire | sostituzione booleana (K key, V oldValue, V newValue) | Sostituisce il vecchio valore con un nuovo valore per una determinata chiave |
| sostituisci tutto | void replaceAll (funzione BiFunction) | Invoca la funzione data per sostituire tutte le voci della mappa |
| putIfAbsent | V putIfAbsent (tasto K, valore V) | Inserisce la chiave data, valore solo se non è già presente |
| calcolare | Calcolo V (tasto K, funzione di rimappatura BiFunction) | Calcola la mappatura per la chiave e il valore specificati data la funzione di mappatura. |
| computeIfAbsent | V computeIfAbsent (tasto K, Function mappingFunction) | Calcola il valore per la chiave data utilizzando la funzione di mappatura se non è già presente. |
| computeIfPresent | V computeIfPresent (tasto K, BiFunction remappingFunction) | Calcola una nuova mappatura per la chiave data con la funzione di rimappatura data se il valore della chiave è già presente |
| partire | Unione V (tasto K, valore V, funzione di rimappatura BiFunction) | Associa una determinata chiave al valore se non è già associata o è associata al valore null. |
Tutti i metodi di cui sopra sono supportati dall'interfaccia della mappa. Notare che i metodi che appaiono ombreggiati sono i nuovi metodi inclusi in Java 8.
Implementazione di Java Map
Il seguente programma implementa un esempio di mappa in Java. Qui usiamo la maggior parte dei metodi discussi sopra.
L'esempio mostra varie operazioni get, put e set.
import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } } Produzione:
Chiave = CHN, Valore: Cina
Chiave = XX, Valore: null
null keyExists: true, null valueExists = true
voce impostata per country_map: (null = Z, XX = null, CHN = Cina, SL = Srilanka, IND = India, KOR = Corea)
Dimensioni di country_map: 6
data_map mappato a country_map: {null = Z, XX = null, CHN = Cina, SL = Srilanka, IND = India, KOR = Kore
per}
valore della chiave null per data_map: Z
data_map dopo aver rimosso la chiave nulla = {XX = null, CHN = Cina, SL = Srilanka, IND = India, KOR = Corea}
chiavi mappa dati: (null, XX, CHN, SL, IND, KOR)
valori mappa dati: (Z, null, Cina, Srilanka, India, Corea)
mappa dei dati dopo l'operazione di cancellazione, è vuoto: vero
Ordinamento di una mappa in Java
Poiché una mappa è composta da coppie chiave-valore, possiamo ordinare la mappa in base a chiavi o valori.
In questa sezione, ordineremo una mappa sia per le chiavi che per i valori.
Ordina per chiave
Per ordinare una mappa sui tasti, possiamo usare una mappa ad albero. La mappa ad albero ordina automaticamente le chiavi. Il seguente programma Java converte una mappa in una mappa ad albero e visualizza le chiavi ordinate.
import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println(' ' + entry.getKey() + ' ' + entry.getValue()); } } }Produzione:
Mappa originale non ordinata:
Un'America
C Cina
D Danimarca
X Hongkong
I India
Mappa ordinata per chiave:
Un'America
C Cina
D Danimarca
I India
X Hongkong
Il programma precedente crea una mappa composta da un singolo codice alfabetico come chiavi e nomi di paesi come valori. Innanzitutto, visualizziamo la mappa originale che non è ordinata. Quindi convertiamo la mappa in una mappa ad albero che ordina automaticamente le chiavi. Infine, mostriamo la mappa ad albero ordinata sui tasti.
Ordina per valore
Per ordinare una mappa in base ai valori, convertiamo prima la mappa in un elenco. Quindi ordiniamo questo elenco utilizzando il metodo Collections.sort () che utilizza un comparatore per confrontare i valori e disporli in un ordine specifico.
Una volta che l'elenco è stato ordinato, le voci dell'elenco collegato vengono nuovamente copiate sulla mappa che ci fornisce la mappa ordinata.
Il seguente programma Java mostra l'ordinamento di una mappa in base al valore. Il programma utilizza LinkedHashMap che viene passato alla funzione di ordinamento. Nella funzione di ordinamento, viene convertito in un elenco collegato e ordinato. Dopo l'ordinamento, viene riconvertito in LinkedHashMap.
cambia char in int c ++
import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println(' Key Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println(' ' + entry.getKey()+ ' ' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } } Produzione:
Mappa originale non ordinata:
{NEP = Kathmandu, IND = Nuova Delhi, USA = Washington, UK = Londra, AUS = Canberra
Mappa ordinata per valore:
Valore chiave
DA Canberra
NEP Kathmandu
Regno Unito Londra
IND Nuova Delhi
USA Washington
Mappa simultanea in Java
Un concurrentMap è un'interfaccia che eredita dall'interfaccia java.util.map. L'interfaccia concurrentMap è stata introdotta per la prima volta in JDK 1.5 e fornisce una mappa che gestisce l'accesso simultaneo.
L'interfaccia concurrentMap fa parte del pacchetto java.util.concurrent.
Il seguente programma Java mostra concurrentMap in Java.
import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }Produzione:
Mappa simultanea iniziale: {100 = rosso, 101 = verde, 102 = blu}
Dopo aver aggiunto la chiave assente 103: {100 = rosso, 101 = verde, 102 = blu, 103 = viola}
Mappa simultanea dopo la rimozione di 101: {100 = rosso, 102 = blu, 103 = viola}
Aggiungi la chiave assente 101: {100 = rosso, 101 = marrone, 102 = blu, 103 = viola}
Sostituisci il valore alla chiave 101: {100 = Rosso, 101 = Verde, 102 = Blu, 103 = Viola}
Mappa sincronizzata in Java
Una mappa sincronizzata è una mappa thread-safe e supportata da una determinata mappa. In Java, la mappa sincronizzata viene ottenuta utilizzando il metodo synchronizedMap () della classe java.util.Collections. Questo metodo restituisce una mappa sincronizzata per una determinata mappa.
Questa mappa sincronizzata restituita viene utilizzata per accedere alla mappa di backup per ottenere l'accesso seriale.
La dichiarazione generale del metodo synchronizedMap () è:
public static Map synchronizedMap(Map m) dove m => è la mappa supportata.
Come già accennato questo metodo restituisce la visualizzazione sincronizzata della mappa m.
Il seguente programma Java è un esempio di mappa sincronizzata.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } } Produzione:
Mappa originale (con supporto): {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Mappa sincronizzata dopo la rimozione (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Mappa statica in Java
Una mappa statica in Java è una mappa dichiarata statica proprio come una variabile statica. Dichiarando una mappa statica, diventa una variabile di classe accessibile senza utilizzare l'oggetto.
Esistono due approcci per creare e inizializzare una mappa statica in Java.
# 1) Utilizzo di una variabile statica
Qui creiamo una variabile di mappa statica e la istanziamo insieme alla dichiarazione.
Questo approccio è dimostrato nel seguente programma Java.
import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }Produzione:
Mappa statica utilizzando la variabile della mappa statica:
{1 = India, 2 = Portogallo, 3 = Germania}
# 2) Utilizzo del blocco statico
In questo, creiamo una variabile di mappa statica. Quindi creiamo un blocco statico e all'interno di questo blocco statico inizializziamo la variabile map.
Il programma seguente lo dimostra.
import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } } Produzione:
Mappa statica utilizzando il blocco statico:
{1 = rosso, 2 = verde, 3 = blu}
Conversione dell'elenco in mappa
In questa sezione discuteremo i metodi per convertire l'elenco in una mappa.
I due metodi includono:
Metodo tradizionale
Nel metodo tradizionale, ogni elemento dell'elenco viene copiato sulla mappa utilizzando un ciclo for-each.
Questa implementazione è mostrata di seguito:
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } } Produzione:
L'elenco fornito: (Rosso, Verde, Blu, Marrone, Bianco)
Mappa generata dall'elenco: {1 = rosso, 2 = verde, 3 = blu, 4 = marrone, 5 = bianco}
Elenco da mappare in Java 8
Possiamo anche utilizzare il metodo Java 8 Collectors.mapOf () che convertirà l'elenco fornito in una mappa.
Il programma seguente lo dimostra.
import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } } Produzione:
Mappa ottenuta dalla lista: {1 = Abacus, 2 = Maths, 3 = Physics, Chemistry}
In questo programma, abbiamo una classe Subject che funge da classe list. L'oggetto della classe ha due campi, ovvero sub_id e sub_name. Abbiamo metodi per leggere i valori dei campi dalla classe. Nella funzione principale, creiamo oggetti di questa classe e costruiamo una lista.
cosa posso fare con c ++
Questo elenco viene quindi convertito nella mappa utilizzando il metodo Collectors.MapOf che prende gli elementi uno per uno. Prende anche il sub_Id come chiave per la mappa. Infine, viene generata la mappa che ha sub_Id come chiave e Sub_Name come valore.
Converti mappa in stringa in Java
Una raccolta di mappe può essere convertita in una stringa utilizzando due approcci:
Utilizzando StringBuilder
Qui creiamo un oggetto StringBuilder e quindi copiamo le coppie chiave-valore della mappa nell'oggetto StringBuilder. Quindi convertiamo l'oggetto StringBuilder in una stringa.
Il programma seguente mostra il codice Java per convertire la mappa nella stringa.
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }Produzione:
La mappa data: {20 = Venti, 40 = Quaranta, 10 = Dieci, 30 = Trenta}
La rappresentazione di stringa di map:
{20 = venti, 40 = quaranta, 10 = dieci, 30 = trenta}
Utilizzo di Java 8 Streams
In questo metodo, creiamo un flusso dalle chiavi della mappa e quindi lo convertiamo nella stringa.
Il programma fornito di seguito mostra la conversione della mappa in una stringa utilizzando flussi.
import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }Produzione:
La mappa data: {20 = Venti, 40 = Quaranta, 10 = Dieci, 30 = Trenta}
La rappresentazione di stringa di map:
{20 = venti, 40 = quaranta, 10 = dieci, 30 = trenta}
Converti mappa in elenco in Java
Una mappa è composta da chiavi e valori mentre un elenco è una sequenza di singoli elementi. Quando si converte la mappa in un elenco, di solito convertiamo le chiavi in un elenco di chiavi e i valori in un elenco di valori.
Il seguente programma Java mostra questa conversione.
import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }Produzione:
Elenco delle chiavi dalla mappa data:
(50, 20, 40, 10, 30)
Elenco dei valori dalla mappa data:
(magenta, verde, ciano, rosso, blu)
Dizionario vs. Mappa in Java
Discutiamo alcune delle principali differenze tra un dizionario e una mappa in Java.
| Dizionario | Carta geografica |
|---|---|
| Il dizionario è una classe astratta. | La mappa è un'interfaccia. |
| Le classi e i metodi utilizzati dalla classe del dizionario sono precedenti al framework delle raccolte. | Classi e metodi utilizzati dalle classi map fanno parte del framework di raccolta. |
| Se una classe estende il dizionario, non può estendere nessun'altra classe poiché Java supporta solo l'ereditarietà singola | La mappa è un'interfaccia, quindi una classe può ereditare dalla mappa e da altre interfacce |
| Vecchia implementazione. Quasi obsoleto nelle versioni più recenti di Java. | L'interfaccia della mappa ha sostituito l'implementazione del dizionario. |
Domande frequenti
D # 1) Perché usiamo un'interfaccia mappa in Java?
Risposta: La mappa è un'interfaccia in Java implementata dalle classi che memorizzano i dati come coppie chiave-valore. L'interfaccia della mappa fornisce operazioni / metodi che possono essere eseguiti su coppie chiave-valore come inserimento, aggiornamento, eliminazione, ecc.
Q # 2)Cosa significa MAP in Java?
Risposta: Una mappa in Java rappresenta una mappatura di una chiave con un valore specifico. Una mappa Java memorizza queste coppie chiave-valore in una mappa. Possiamo cercare e recuperare il valore associato a una chiave semplicemente utilizzando la chiave nella mappa.
Una mappa viene implementata in Java utilizzando un'interfaccia che non fa parte dell'interfaccia Collection. Ma la mappa è una raccolta.
Q # 3)Cos'è MAP get?
Risposta: Get () è un metodo fornito da un'interfaccia map in Java che viene utilizzata per recuperare il valore associato a una particolare chiave fornita come argomento al metodo get (). Se il valore non è presente, viene restituito un valore nullo.
Q # 4)La mappa è una raccolta?
Risposta: Sebbene la mappa sia vista come una raccolta in generale, non implementa un'interfaccia di raccolta. Alcune delle implementazioni di map, come la mappa ad albero non supportano valori o chiavi nulli.
Q # 5)Qual è la differenza tra set e map?
Risposta: Set è una raccolta di sole chiavi mentre la mappa è una raccolta di coppie chiave-valore. Sebbene il set non consenta valori nulli, alcune delle implementazioni della mappa consentono valori nulli.
Il set non consente la duplicazione di chiavi. La mappa può consentire valori duplicati ma le chiavi devono essere univoche. Set viene solitamente utilizzato quando si desidera memorizzare una raccolta di elementi unici. La mappa può essere utilizzata quando è necessario memorizzare i dati sotto forma di coppie chiave-valore.
Conclusione
In questo tutorial, abbiamo discusso le basi dell'interfaccia della mappa. Abbiamo anche visto i vari metodi e tutti gli altri dettagli relativi all'interfaccia della mappa in Java. Siamo venuti a sapere che ci sono varie implementazioni di interfacce mappa tra cui treemap, hashmap, ecc.
Nei nostri prossimi tutorial, discuteremo in modo più dettagliato questa implementazione della mappa.
=> Visita qui per imparare Java da zero.
Lettura consigliata
- Cos'è una HashMap in Java?
- TreeMap in Java - Tutorial con esempi di Java TreeMap
- LinkedHashMap in Java - Esempio e implementazione di LinkedHashMap
- Set Interface In Java: Java Set Tutorial with examples
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Tutorial Java Stack: implementazione della classe Stack con esempi
- Tutorial Java Reflection con esempi
- Jagged Array in Java - Tutorial con esempi