Scopri come utilizzare la struttura dati Java HashMap

Una HashMap (o una HashTable) è una struttura dati che consente un rapido accesso ai dati utilizzando coppie chiave-valore. La classe Java HashMap estende il file Mappa astratta class e implementa l'interfaccia Map, che gli dà accesso a molte operazioni. Le HashMap hanno due parametri di tipo: K e V, dove K memorizza le chiavi e V memorizza i valori in ciascuna HashMap.

HashMap ti consente di mappare le chiavi su un valore specifico e di memorizzare gli elementi in ordine casuale. In questo articolo imparerai come utilizzare la classe HashMap di Java per archiviare, recuperare, aggiornare ed eliminare i dati.

Creazione di una HashMap Java

La classe Java HashMap ha quattro costruttori. Il costruttore predefinito è il più popolare, ti consente di creare una HashMap vuota che avrà una capacità predefinita di 16.

importareGiava.util.HashMap;
pubblicoclassePrincipale{
pubblicostaticovuotoprincipale(Stringa[] argomenti){
//creazione di una HashMap
 HashMap<Intero, Stringa> fruitMap = nuova HashMap<Intero, Stringa>();
 }
}

Il classe Java sopra usa il costruttore HashMap predefinito per creare una struttura di dati chiamata fruttiMappa. L'oggetto fruitsMap memorizzerà i dati che hanno una chiave intera e un valore stringa. Tuttavia, poiché la classe HashMap implementa l'interfaccia Map, può memorizzare un valore nullo nel campo chiave, nel campo valore o in entrambi.

Memorizzazione dei dati in una HashMap

Puoi eseguire diverse operazioni usando la classe HashMap. Il put (tasto K, valore V) Il metodo è tra i suoi metodi più popolari e consente di archiviare i dati utilizzando una coppia chiave-valore, in cui ogni chiave viene mappata a un valore.

importareGiava.util.HashMap;
pubblicoclassePrincipale{
pubblicostaticovuotoprincipale(Stringa[] argomenti){
//creazione di una HashMap
 HashMap<Intero, Stringa> fruitMap = nuova HashMap<Intero, Stringa>();
//aggiungi elementi a HashMap
 fruttiMap.put (3,"Pera");
 fruttiMap.put (6,"Mango");
 fruttiMap.put (7,"Prugna");
 fruttiMap.put (4,"Mela");
 fruttiMap.put (1,"Arancia");
 fruttiMap.put (5,"Frutti di bosco");
 fruttiMap.put (2,"Melone");
 }
}

La classe aggiornata sopra usa il metodo put() per aggiungere diversi frutti e la loro chiave alla struttura dati esistente di fruitsMap. È importante notare che il codice sopra aggiunge i dati alla mappa in modo casuale. Questo dettaglio diventerà utile quando inizierai a leggere i dati dalla HashMap.

Lettura di dati da una HashMap

Esistono diversi modi per leggere i dati da una HashMap. Il metodo che utilizzi dipenderà da come vuoi che appaiano i dati o anche dal tipo di dati che desideri recuperare.

Recupera l'oggetto HashMap

Se vuoi recuperare i dati come un oggetto, puoi semplicemente accedere all'oggetto HashMap, che nell'esempio seguente è fruitsMap.

//Visualizza tutti gli elementi come un oggetto
Sistema.fuori.println(fruttiMappa);

Aggiungendo la riga di codice sopra alla classe Main, stampa il seguente output nella console:

{1=Arancia, 2=Melone, 3=Pera, 4=Mela, 5=Bacche, 6=Mango, 7=Prugna}

Sebbene ogni valore sia stato aggiunto casualmente all'HashMap, dall'output vedrai che HashMap memorizza i valori in ordine crescente, in base alla chiave assegnata a ciascun valore. Questa è una funzionalità che mette HashMaps davanti ad altre strutture di dati come il Struttura dei dati dell'array che supportano solo l'archiviazione lineare.

Recupera tutti i dati singolarmente

Se desideri recuperare tutti i dati singolarmente, puoi utilizzare il file per metodo che consente di attraversare la HashMap e stampare ogni valore e la chiave corrispondente. Questo metodo utilizza l'interfaccia Map implementata dalla classe HashMap.

//visualizza tutti gli elementi con un iteratore 
per (HashMap. Iscrizione<Intero, Stringa> frutta: fruitsMap.entrySet()) 
{ 
 System.out.println("Chiave: " + fruit.getKey() + " Valore: " + fruit.getValue()); 
}

L'aggiunta del metodo sopra al tuo codice stamperà il seguente output nella tua console:

Legenda: 1 Valore: Arancio
Legenda: 2 Valore: Melone
Legenda: 3 Valore: Pera
Chiave: 4 Valore: Mela
Legenda: 5 Valore: Frutti di bosco
Legenda: 6 Valore: Mango
Legenda: 7 Valore: Prugna

Recupera un valore specifico

La classe HashMap ha a ottenere() metodo che accetta una chiave e restituisce il valore mappato su questa chiave.

//preleva un singolo elemento
Sistema.fuori.println(fruttiMappa.ottenere(4));

La riga di codice sopra stampa il seguente output nella console:

Mela

Aggiornamento dei dati in una HashMap

Dopo aver creato e popolato un oggetto HashMap, puoi utilizzare il file sostituire() metodo per aggiornare qualsiasi elemento nella mappa. Il metodo replace() accetta due o tre argomenti. Il primo metodo replace() prende la chiave associata a un elemento esistente, insieme al nuovo valore che si desidera mappare su di esso.

// sostituisce un singolo elemento
fruttiMap.sostituisci (4, "Uva");
Sistema.fuori.Stampa(fruttiMappa);

L'esecuzione del codice precedente stampa il seguente oggetto nella console:

{1=Arancia, 2=Melone, 3=Pera, 4=Uva, 5=Bacche, 6=Mango, 7=Prugna}

Come puoi vedere dall'oggetto sopra, "Uva" viene mappata su 4, che in precedenza era mappata su "Apple".

Il secondo metodo replace() prende la chiave associata all'elemento esistente, all'elemento esistente e al valore di sostituzione.

// sostituisce un singolo elemento
 fruttiMap.sostituisci (4, "Mela", "Uva");
Sistema.fuori.Stampa(fruttiMappa);

Il codice sopra stampa il seguente oggetto nella console:

{1=Arancia, 2=Melone, 3=Pera, 4=Uva, 5=Bacche, 6=Mango, 7=Prugna}

Eliminazione di dati da una HashMap

Puoi eliminare un elemento specifico dalla tua HashMap usando il rimuovere() metodo o eliminare tutti i dati utilizzando il chiaro() metodo. Il metodo remove() accetta uno o due argomenti. Il primo metodo di rimozione prende la chiave associata al valore che si desidera rimuovere:

//elimina un singolo elemento
fruttiMappa.rimuovere(5);
Sistema.fuori.println(fruttiMappa);

Il codice sopra stampa il seguente oggetto nella console:

{1=Arancia, 2=Melone, 3=Pera, 4=Mela, 6=Mango, 7=Prugna}

L'oggetto aggiornato mostra che l'elemento con la coppia chiave-valore di 5 e "Bacche" non fa più parte della fruitsMap. Il secondo metodo remove() prende una chiave e il valore a cui esegue il mapping.

//elimina un singolo elemento
fruttiMap.remove (5, "Frutti di bosco");
Sistema.fuori.println(fruttiMappa);

Il codice sopra stampa anche il seguente oggetto nella console:

{1=Arancia, 2=Melone, 3=Pera, 4=Mela, 6=Mango, 7=Prugna}

Il metodo clear() non accetta argomenti e restituisce void.

fruttiMappa.chiaro();
Sistema.fuori.println(fruttiMappa);

L'esecuzione del codice precedente stampa il seguente oggetto vuoto nella console:

{}

Ora puoi eseguire operazioni CRUD su una HashMap Java

Le HashMaps sono una delle numerose strutture di dati popolari che devi conoscere. Questo articolo spiega come eseguire operazioni CRUD su Java HashMaps. HashMap è una struttura dati molto utile, il suo principale punto di forza è che è una delle strutture dati più efficienti, grazie alla sua velocità di accesso. Tuttavia, è anche molto comodo da usare, poiché consente l'archiviazione casuale.