In Java, Map Interface è presente nel pacchetto java.util rappresenta una mappatura tra una chiave e un valore. L'interfaccia Java Map non è un sottotipo di Interfaccia di raccolta . Pertanto si comporta in modo leggermente diverso dal resto dei tipi di raccolta. Una mappa contiene chiavi univoche.
Geek, il brainstormer avrebbe dovuto essere perché e quando utilizzare Maps.
Le mappe sono perfette da utilizzare per la mappatura di associazioni di valori-chiave come i dizionari. Le mappe vengono utilizzate per eseguire ricerche per chiavi o quando qualcuno vuole recuperare e aggiornare elementi per chiavi. Alcuni scenari comuni sono i seguenti:
- Una mappa dei codici di errore e delle relative descrizioni.
- Una mappa di codici postali e città.
- Una mappa di manager e dipendenti. Ad ogni manager (chiave) è associato un elenco di dipendenti (valore) che gestisce.
- Una mappa delle classi e degli studenti. Ad ogni classe (chiave) è associato un elenco di studenti (valore).
Creazione di oggetti sulla mappa
Poiché Map è un file interfaccia , non è possibile creare oggetti della mappa di tipo. Abbiamo sempre bisogno di una classe che estenda questa mappa per creare un oggetto. E inoltre, dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nella Mappa.
Sintassi: Definizione della mappa indipendente dai tipi
Map hm = new HashMap(); // Obj is the type of the object to be stored in Map>
Caratteristiche di un'interfaccia cartografica
- Una mappa non può contenere chiavi duplicate e ciascuna chiave può essere associata al massimo a un valore. Alcune implementazioni consentono chiavi nulle e valori nulli come HashMap e LinkedHashMap , ma ad alcune non piace Mappa ad albero .
- L'ordine di una mappa dipende dalle implementazioni specifiche. Per esempio, Mappa ad albero e LinkedHashMap hanno ordini prevedibili, mentre HashMap no.
- Sono disponibili due interfacce per l'implementazione di Map in Java. Sono Map e SortedMap e tre classi: HashMap, TreeMap e LinkedHashMap.
Metodi nell'interfaccia Java Map
| Metodo | Azione eseguita |
|---|---|
| chiaro() | Questo metodo viene utilizzato in Java Map Interface per cancellare e rimuovere tutti gli elementi o le mappature da una raccolta di mappe specificata. |
| contieneChiave(Oggetto) | Questo metodo viene utilizzato nell'interfaccia della mappa in Java per verificare se una particolare chiave viene mappata o meno nella mappa. Prende l'elemento chiave come parametro e restituisce True se quell'elemento è mappato nella mappa. |
| contieneValore(Oggetto) | Questo metodo viene utilizzato nell'interfaccia della mappa per verificare se un particolare valore viene mappato da una o più chiavi nella mappa. Prende il valore come parametro e restituisce True se quel valore è mappato da una qualsiasi delle chiavi nella mappa. |
| set di voci() | Questo metodo viene utilizzato in Map Interface in Java per creare un insieme degli stessi elementi contenuti nella mappa. Fondamentalmente restituisce una vista impostata della mappa oppure possiamo creare un nuovo insieme e memorizzare gli elementi della mappa al suo interno. |
| uguale(Oggetto) | Questo metodo viene utilizzato in Java Map Interface per verificare l'uguaglianza tra due mappe. Verifica se gli elementi di una mappa passati come parametro sono uguali agli elementi di questa mappa oppure no. |
| ottenere(Oggetto) | Questo metodo viene utilizzato per recuperare o recuperare il valore mappato da una particolare chiave menzionata nel parametro. Restituisce NULL quando la mappa non contiene tale mappatura per la chiave. |
| codice hash() | Questo metodo viene utilizzato nell'interfaccia della mappa per generare un hashCode per la mappa specificata contenente chiavi e valori. |
| è vuoto() | Questo metodo viene utilizzato per verificare se una mappa contiene voci per coppie chiave e valore. Se non esiste alcuna mappatura, restituisce true. |
| mazzo di chiavi() | Questo metodo viene utilizzato nell'interfaccia della mappa per restituire una vista Set delle chiavi contenute in questa mappa. Il set è supportato dalla mappa, quindi le modifiche alla mappa si riflettono nel set e viceversa. |
| mettere(Oggetto, Oggetto) | Questo metodo viene utilizzato in Java Map Interface per associare il valore specificato alla chiave specificata in questa mappa. |
| putAll(Mappa) | Questo metodo viene utilizzato in Map Interface in Java per copiare tutte le mappature dalla mappa specificata a questa mappa. |
| rimuovi(Oggetto) | Questo metodo viene utilizzato nell'interfaccia della mappa per rimuovere la mappatura di una chiave da questa mappa se è presente nella mappa. |
| misurare() | Questo metodo viene utilizzato per restituire il numero di coppie chiave/valore disponibili nella mappa. |
| valori() | Questo metodo viene utilizzato in Java Map Interface per creare una raccolta dai valori della mappa. Fondamentalmente restituisce una vista Raccolta dei valori nell'HashMap. |
| getOrDefault(Chiave oggetto, V defaultValue) | Restituisce il valore a cui è mappata la chiave specificata oppure defaultValue se questa mappa non contiene alcuna mappatura per la chiave. |
| unisci (tasto K, valore V, funzione di rimappatura BiFunzione) | Se la chiave specificata non è già associata a un valore o è associata a null, associala al valore non null specificato. |
| putIfAbsent(chiave K, valore V) | Se la chiave specificata non è già associata a un valore (o è mappata su null) la associa al valore specificato e restituisce null, altrimenti restituisce il valore associato corrente. |
Esempio:
Giava
// Java Program to Demonstrate> // Working of Map interface> > // Importing required classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty HashMap> >Map hm> >=>new> HashMap();> > >// Inserting pairs in above Map> >// using put() method> >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 Map using for-each loop> >for> (Map.Entry me :> >hm.entrySet()) {> > >// Printing keys> >System.out.print(me.getKey() +>':'>);> >System.out.println(me.getValue());> >}> >}> }> |
>
>Produzione:
a:100 b:200 c:300 d:400>
Le classi che implementano l'interfaccia Mappa sono rappresentate nei media seguenti e descritte successivamente come segue:
quanto pesa kat timpf?
1. HashMap
HashMap fa parte della raccolta Java a partire da Java 1.2. Fornisce l'implementazione di base dell'interfaccia Map di Java. Memorizza i dati in coppie (Chiave, Valore). Per accedere ad un valore è necessario conoscerne la chiave. Questa classe utilizza una tecnica chiamata Java
// Java Program to illustrate the Hashmap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty HashMap> >Map map =>new> HashMap();> > >// Inserting entries in the Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Produzione
vaibhav 20 vishal 10 sachin 30>
2. HashMap collegato
LinkedHashMap è proprio come HashMap con la funzionalità aggiuntiva di mantenere un ordine di elementi inseriti al suo interno. HashMap ha fornito il vantaggio dell'inserimento, della ricerca e dell'eliminazione rapidi, ma non ha mai mantenuto la traccia e l'ordine di inserimento forniti da LinkedHashMap in cui è possibile accedere agli elementi nel loro ordine di inserimento. Vediamo come creare un oggetto mappa utilizzando questa classe.
Esempio
Giava
// Java Program to Illustrate the LinkedHashmap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty LinkedHashMap> >Map map =>new> LinkedHashMap();> > >// Inserting pair entries in above Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Produzione
vishal 10 sachin 30 vaibhav 20>
3. Mappa ad albero
IL Mappa ad albero in Java viene utilizzato per implementare l'interfaccia Map e NavigableMap insieme alla classe Abstract. La mappa viene ordinata secondo l'ordine naturale delle sue chiavi, o da un comparatore fornito al momento della creazione della mappa, a seconda del costruttore utilizzato. Questo si rivela un modo efficiente per ordinare e archiviare le coppie chiave-valore. L'ordine di memorizzazione mantenuto dalla mappa ad albero deve essere coerente con gli uguali proprio come qualsiasi altra mappa ordinata, indipendentemente dai comparatori espliciti. Vediamo come creare un oggetto mappa utilizzando questa classe.
Esempio
Giava
stringa Java in JSON
// Java Program to Illustrate TreeMap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty TreeMap> >Map map =>new> TreeMap();> > >// Inserting custom elements in the Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map using for each loop> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
attore cinematografico Vijay
>
>Produzione
sachin 30 vaibhav 20 vishal 10>
Esecuzione di operazioni utilizzando Interfaccia della mappa E Classe HashMap
Poiché Map è un'interfaccia, può essere utilizzata solo con una classe che implementa questa interfaccia. Ora vediamo come eseguire alcune operazioni utilizzate di frequente su una mappa utilizzando le opzioni ampiamente utilizzate Classe HashMap . E inoltre, dopo l'introduzione di Generici in Java 1.5 è possibile limitare il tipo di oggetto che può essere memorizzato nella mappa.
1. Aggiunta di elementi
Per aggiungere un elemento alla mappa possiamo utilizzare il metodo put() . Tuttavia, l'ordine di inserimento non viene mantenuto nell'hashmap. Internamente, per ogni elemento, viene generato un hash separato e gli elementi vengono indicizzati in base a questo hash per renderlo più efficiente.
Esempio
Giava
// 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 hm1 =>new> HashMap();> > >// Initialization of a Map> >// using Generics> >Map hm2> >=>new> HashMap();> > >// 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);> >}> }> |
>
>Produzione
{1=Geeks, 2=For, 3=Geeks} {1=Geeks, 2=For, 3=Geeks}> 2. Modifica dell'elemento
Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, è possibile farlo aggiungendo nuovamente l'elemento con il metodo put(). Dato che gli elementi della mappa vengono indicizzati tramite chiavi, è possibile modificare il valore della chiave semplicemente inserendo il valore aggiornato della chiave che si desidera modificare.
Esempio
Giava
// 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 hm1> >=>new> HashMap();> > >// 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);> >}> }> |
>
mappa reactjs
>Produzione
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Rimozione di elementi
Per rimuovere un elemento dalla Mappa possiamo utilizzare il metodo Remove() . Questo metodo prende il valore della chiave e rimuove la mappatura per una chiave da questa mappa se è presente nella mappa.
Esempio
Giava
// 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 hm1> >=>new> HashMap();> > >// 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);> >}> }> |
>
>Produzione
{1=Geeks, 2=For, 3=Geeks, 4=For} {1=Geeks, 2=For, 3=Geeks}> 4. Iterazione attraverso la mappa
Esistono diversi modi per scorrere la mappa. Il modo più famoso è utilizzare un ciclo for-each e ottenere le chiavi. Il valore della chiave viene trovato utilizzando il metodo getValue().
Esempio
Giava
// 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 hm1> >=>new> HashMap();> > >// 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);> >}> >}> }> |
mappa java
>
>Produzione
1 : Geeks 2 : For 3 : Geeks>
5. Conta la presenza di numeri utilizzando Hashmap
In questo codice, stiamo utilizzando putIfAbsent( ) insieme a Collezioni.frequenza() per contare l'esatta occorrenza dei numeri. In molti programmi è necessario contare le occorrenze di un particolare numero o lettera. Utilizzare il seguente approccio per risolvere questi tipi di problemi
Giava
// Java program to Count the Occurrence> // of numbers using Hashmap> import> java.util.*;> > class> HelloWorld {> >public> static> void> main(String[] args)> >{> >int> a[] = {>1>,>13>,>4>,>1>,>41>,>31>,>31>,>4>,>13>,>2> };> > >// put all elements in arraylist> >ArrayList aa =>new> ArrayList();> >for> (>int> i =>0>; i aa.add(a[i]); } HashMap h = new HashMap(); // counting occurrence of numbers for (int i = 0; i h.putIfAbsent(aa.get(i), Collections.frequency( aa, aa.get(i))); } System.out.println(h); } }> |
>
>Produzione
{1=2, 2=1, 4=2, 41=1, 13=2, 31=2}> Domande frequenti nell'interfaccia della mappa Java
Q1. Cos'è un'interfaccia cartografica in Java?
Risposta:
La mappa contiene coppie chiave-valore, in cui accediamo agli elementi nella mappa utilizzando valori chiave.
Q2. Quali sono i tipi di interfacce di mappa in Java?
Risposta:
Esistono 3 implementazioni dell'interfaccia della mappa HashMap, LinkedHashMap e TreeMap.