logo

HashMap in Java

In Java, HashMap fa parte della raccolta Java a partire da Java 1.2. Questa classe si trova in java.util pacchetto. Fornisce l'implementazione di base dell'interfaccia Map di Java. HashMap in Java memorizza i dati in coppie (Chiave, Valore) e puoi accedervi tramite un indice di un altro tipo (ad esempio un numero intero). Un oggetto viene utilizzato come chiave (indice) per un altro oggetto (valore). Se provi a inserire la chiave duplicata in HashMap, sostituirà l'elemento della chiave corrispondente.

come rivelare le app nascoste

Cos'è HashMap?

Java Hash Map è simile a HashTable , ma non è sincronizzato. Consente di memorizzare anche le chiavi null, ma dovrebbe esserci un solo oggetto chiave null e può esserci un numero qualsiasi di valori null. Questa classe non garantisce l'ordine della mappa. Per utilizzare questa classe e i suoi metodi, è necessario importare java.util.HashMap pacchetto o la sua superclasse.

Tabella dei contenuti



Esempi di HashMap Java

Di seguito è riportata l'implementazione di un esempio di Java HashMap:

Giava




// Java program to illustrate HashMap class> // of java.util package> // Importing HashMap class> import> java.util.HashMap;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Create an empty hash map by declaring object> >// of string and integer type> >HashMap map =>new> HashMap();> >// Adding elements to the Map> >// using standard put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Print size and content of the Map> >System.out.println(>'Size of map is:- '> >+ map.size());> >// Printing elements in object of Map> >System.out.println(map);> >// Checking if a key is present and if> >// present, print value by passing> >// random element> >if> (map.containsKey(>'vishal'>)) {> >// Mapping> >Integer a = map.get(>'vishal'>);> >// Printing value for the corresponding key> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }>

>

>

Produzione

Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10>

HashMap Dichiarazione

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>

parametri:

Richiede due parametri e precisamente i seguenti:

  • Il tipo di chiavi gestite da questa mappa
  • Il tipo di valori mappati

Nota: K eys e value non possono essere di tipo dati primitivo. La chiave in Hashmap è valida se implementa metodo hashCode() e equals() , dovrebbe anche essere immutabile (oggetto personalizzato immutabile) in modo che l'hashcode e l'uguaglianza rimangano costanti. Il valore in hashmap può essere qualsiasi classe wrapper, oggetti personalizzati, array, qualsiasi tipo di riferimento o anche null .

Per esempio : Hashmap può avere un array come valore ma non come chiave.

HashMap negli implementazioni Java Serializzabile , Clonabile , Carta geografica interfacce.Java HashMap si estende Mappa astratta classe. Le sottoclassi dirette sono LinkedHashMap E PrinterStateReasons .

Gerarchia di Java HashMap

Gerarchia di HashMap in Java

Caratteristiche di Java HashMap

Una HashMap è una struttura dati utilizzata per archiviare e recuperare valori in base alle chiavi. Alcune delle caratteristiche chiave di una hashmap includono:

  • Tempo di accesso veloce : Le HashMap forniscono un accesso temporale costante agli elementi, il che significa che il recupero e l'inserimento degli elementi sono molto rapidi, solitamente con una complessità temporale O(1).
  • Utilizza la funzione di hashing : HashMaps utilizza una funzione hash per mappare le chiavi sugli indici in un array. Ciò consente una rapida ricerca dei valori in base alle chiavi.
  • Memorizza le coppie chiave-valore: Ogni elemento in una HashMap è costituito da una coppia chiave-valore. La chiave viene utilizzata per cercare il valore associato.
  • Supporta chiavi e valori null : HashMaps consente valori e chiavi null. Ciò significa che è possibile utilizzare una chiave nulla per memorizzare un valore e un valore nullo può essere associato a una chiave.
  • Non ordinato: Le HashMap non sono ordinate, il che significa che l'ordine in cui gli elementi vengono aggiunti alla mappa non viene preservato. Tuttavia, LinkedHashMap è una variante di HashMap che preserva l'ordine di inserimento.
  • Consente duplicati : Le HashMap consentono valori duplicati, ma non chiavi duplicate. Se viene aggiunta una chiave duplicata, il valore precedente associato alla chiave viene sovrascritto.
  • Thread non sicuro : Gli HashMap non sono thread-safe, il che significa che se più thread accedono contemporaneamente alla stessa hashmap, ciò può portare a incoerenze nei dati. Se è richiesta la sicurezza del thread, è possibile utilizzare ConcurrentHashMap.
  • Capacità e fattore di carico : Gli HashMap hanno una capacità, che è il numero di elementi che può contenere, e un fattore di carico, che è la misura di quanto può essere piena l'hashmap prima che venga ridimensionata.

Creazione di HashMap in Java

Cerchiamo di capire come possiamo creare HashMap in Java con un esempio menzionato di seguito:

Giava




// Java Program to Create> // HashMap in Java> import> java.util.HashMap;> // Driver Class> public> class> ExampleHashMap {> >// main function> >public> static> void> main(String[] args) {> > >// Create a HashMap> >HashMap hashMap =>new> HashMap();> > >// Add elements to the HashMap> >hashMap.put(>'John'>,>25>);> >hashMap.put(>'Jane'>,>30>);> >hashMap.put(>'Jim'>,>35>);> > >// Access elements in the HashMap> >System.out.println(hashMap.get(>'John'>));> >// Output: 25> > >// Remove an element from the HashMap> >hashMap.remove(>'Jim'>);> > >// Check if an element is present in the HashMap> >System.out.println(hashMap.containsKey(>'Jim'>));> >// Output: false> > >// Get the size of the HashMap> >System.out.println(hashMap.size());> >// Output: 2> >}> }>

>

>

Produzione

25 false 2>

Costruttori Java HashMap

HashMap fornisce 4 costruttori e il modificatore di accesso di ciascuno è pubblico, elencati come segue:

  1. Mappa hash()
  2. HashMap(int capacità iniziale)
  3. HashMap(int capacità iniziale, float loadFactor)
  4. HashMap (mappa mappa)

Ora discuteremo i costruttori di cui sopra uno per uno insieme all'implementazione degli stessi con l'aiuto di programmi Java puliti.

1. HashMap()

È il costruttore predefinito che crea un'istanza di HashMap con una capacità iniziale di 16 e un fattore di carico di 0,75.

Sintassi:

HashMap hm = new HashMap();>

Esempio

Giava




// Java program to Demonstrate the HashMap() constructor> // Importing basic required classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap();> >// Adding elements using put method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display mapping of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display mapping of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }>

>

>

Produzione

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

2. HashMap(int capacità iniziale)

Crea un'istanza HashMap con a capacità iniziale e fattore di carico specificati 0,75.

Sintassi:

HashMap hm = new HashMap(int initialCapacity);>

Esempio

Giava




// Java program to Demonstrate> // HashMap(int initialCapacity) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> AddElementsToHashMap {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap(>10>);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>2>);> >// Adding elements to object of HashMap> >// using put method> >// HashMap 1> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// HashMap 2> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Printing elements of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Printing elements of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }>

>

>

Produzione

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

3. HashMap(int capacità iniziale, float loadFactor)

Crea un'istanza HashMap con una capacità iniziale specificata e un fattore di carico specificato.

Sintassi:

HashMap hm = new HashMap(int initialCapacity, float loadFactor);>

Esempio

Deviazione standard dei panda

Giava




// Java program to Demonstrate> // HashMap(int initialCapacity,float loadFactor) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the generic type twice> >HashMap hm1> >=>new> HashMap(>5>,>0>.75f);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>3>,>0>.5f);> >// Add Elements using put() method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display elements in object of hashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display elements in object of hashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }>

>

>

Produzione

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

4. HashMap (mappa della mappa)

Crea un'istanza di HashMap con le stesse mappature della mappa specificata.

HashMap hm = nuova HashMap(Mappa mappa);

Giava




// Java program to demonstrate the> // HashMap(Map map) Constructor> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm1 =>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap(hm1);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> > >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }>

>

>

Produzione

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}>

Esecuzione di varie operazioni su HashMap

1. Aggiunta di elementi in HashMap in Java

Per aggiungere un elemento alla mappa, possiamo usare il file Mettere() metodo. 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.

Giava


Java contiene una sottostringa



// Java program to add elements> // to the HashMap> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'Geeks'>);> >hm1.put(>2>,>'For'>);> >hm1.put(>3>,>'Geeks'>);> >hm2.put(>1>,>'Geeks'>);> >hm2.put(>2>,>'For'>);> >hm2.put(>3>,>'Geeks'>);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }>

>

>

Produzione

Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}>

2. Modifica degli elementi in HashMap in Java

Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, è possibile farlo aggiungendo nuovamente l'elemento con il Mettere() metodo. 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.

Giava




// Java program to change> // elements of HashMap> import> java.io.*;> import> java.util.*;> class> ChangeElementsOfHashMap {> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >HashMap hm> >=>new> HashMap();> >// Change Value using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'Geeks'>);> >hm.put(>3>,>'Geeks'>);> >System.out.println(>'Initial Map '> + hm);> >hm.put(>2>,>'For'>);> >System.out.println(>'Updated Map '> + hm);> >}> }>

>

>

Produzione

Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}>

3. Rimozione dell'elemento da Java HashMap

Per rimuovere un elemento dalla Mappa possiamo utilizzare il comando rimuovere() metodo. Questo metodo prende il valore della chiave e rimuove la mappatura per una chiave da questa mappa se è presente nella mappa.

Giava




// Java program to remove> // elements from HashMap> import> java.io.*;> import> java.util.*;> class> RemoveElementsOfHashMap{> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >Map hm> >=>new> HashMap();> >// Add elements using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >hm.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Mappings of HashMap are : '> >+ hm);> >// remove element with a key> >// using remove method> >hm.remove(>4>);> >// Final HashMap> >System.out.println(>'Mappings after removal are : '> >+ hm);> >}> }>

>

>

Produzione

Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}>

4. Attraversamento di Java HashMap

Possiamo utilizzare l'interfaccia Iterator per attraversare qualsiasi struttura del Collection Framework. Poiché gli Iteratori lavorano con un tipo di dati, utilizziamo Entry per risolvere i due tipi separati in un formato compatibile. Quindi utilizzando il metodo next() stampiamo le voci di HashMap.

Giava




// Java program to traversal a> // Java.util.HashMap> import> java.util.HashMap;> import> java.util.Map;> public> class> TraversalTheHashMap {> >public> static> void> main(String[] args)> >{> >// initialize a HashMap> >HashMap map =>new> HashMap();> >// Add elements using put method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Iterate the map using> >// for-each loop> >for> (Map.Entry e : map.entrySet())> >System.out.println(>'Key: '> + e.getKey()> >+>' Value: '> + e.getValue());> >}> }>

>

>

Produzione

Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>

Complessità di HashMap in Java

HashMap fornisce una complessità temporale costante per le operazioni di base, get e put se la funzione hash è scritta correttamente e disperde correttamente gli elementi tra i bucket. L'iterazione su HashMap dipende dalla capacità di HashMap e dal numero di coppie chiave-valore. Fondamentalmente è direttamente proporzionale alla capacità + dimensione. La capacità è il numero di bucket in HashMap. Quindi inizialmente non è una buona idea mantenere un numero elevato di bucket in HashMap.

Diana Ankudinova

Metodi

Complessità temporale

Complessità spaziale

Aggiunta di elementi in HashMap

O(1)

SU)

Rimozione dell'elemento da HashMap

O(1)

SU)

Estrazione di elementi da Java

O(1)

SU)

Caratteristiche importanti di HashMap

Per accedere ad un valore è necessario conoscerne la chiave. HashMap è noto come HashMap perché utilizza una tecnica chiamata Hashing. Hashing è una tecnica per convertire una stringa di grandi dimensioni in una stringa piccola che rappresenta la stessa stringa. Un valore più breve aiuta nell'indicizzazione e nelle ricerche più veloci. HashSet utilizza anche HashMap internamente.
Alcune caratteristiche importanti di HashMap sono:

  • HashMap fa parte del pacchetto java.util.
  • HashMap estende una classe astratta AbstractMap che fornisce anche un'implementazione incompleta dell'interfaccia Map.
  • Implementa anche a Clonabile E Serializzabile interfacce. K e V nella definizione di cui sopra rappresentano rispettivamente Chiave e Valore.
  • HashMap non consente chiavi duplicate ma consente valori duplicati. Ciò significa che una singola chiave non può contenere più di 1 valore ma più di 1 chiave può contenere un singolo valore.
  • HashMap consente anche una chiave nulla, ma solo una volta, e più valori nulli.
  • Questa classe non garantisce l'ordine della mappa; in particolare non garantisce che l'ordine si mantenga costante nel tempo. È più o meno simile a HashTable ma non è sincronizzato.

Struttura interna di HashMap

Internamente HashMap contiene un array di Node e un nodo è rappresentato come una classe che contiene 4 campi:

  1. int hash
  2. Tasto K
  3. Valore V
  4. Nodo successivo

Si può vedere che il nodo contiene un riferimento al proprio oggetto. Quindi è un elenco collegato.

Mappa hash:

Java Hash Map

Nodo:

node_hash_map

Prestazioni di HashMap

Le prestazioni di HashMap dipendono da 2 parametri denominati come segue:

  1. Capacità iniziale
  2. Fattore di carico

1. Capacità iniziale – È la capacità di HashMap al momento della sua creazione (è il numero di bucket che una HashMap può contenere quando viene istanziata HashMap). In Java, inizialmente è 2^4=16, il che significa che può contenere 16 coppie chiave-valore.

2. Fattore di carico – È il valore percentuale della capacità dopo il quale si vuole aumentare la capacità dell’Hashmap (È la percentuale di riempimento dei bucket dopo la quale avviene il Rehashing). In Java, per impostazione predefinita è 0,75f, il che significa che il rehashing avviene dopo aver riempito il 75% della capacità.

3. Soglia – È il prodotto del fattore di carico e della capacità iniziale. In Java, per impostazione predefinita, è (16 * 0,75 = 12). Cioè, il Rehashing avviene dopo aver inserito 12 coppie chiave-valore nell'HashMap.

4. Ripetizione – È il processo di raddoppio della capacità della HashMap dopo aver raggiunto la sua soglia. In Java, HashMap continua a ripetere l'hash (per impostazione predefinita) nella seguente sequenza: 2 ^ 4, 2 ^ 5, 2 ^ 6, 2 ^ 7, .... Presto.

Se la capacità iniziale viene mantenuta più alta, il rehashing non verrà mai eseguito. Ma mantenendolo più alto aumenta la complessità temporale dell'iterazione. Quindi dovrebbe essere scelto in modo molto intelligente per aumentare le prestazioni. Il numero previsto di valori dovrebbe essere preso in considerazione per impostare la capacità iniziale. Il valore del fattore di carico generalmente preferito è 0,75 che fornisce un buon rapporto tra tempo e costi di spazio. Il valore del fattore di carico varia tra 0 e 1.

Nota: Da Java 8 in poi, Java ha iniziato a utilizzare Self Balancing BST invece di un elenco collegato per il concatenamento. Il vantaggio dell'autobilanciamento di bst è che otteniamo il caso peggiore (quando ogni chiave è mappata allo stesso slot) il tempo di ricerca è O (Log n).

HashMap sincronizzato

Come viene detto, HashMap non è sincronizzato, ovvero più thread possono accedervi contemporaneamente. Se più thread accedono contemporaneamente a questa classe e almeno un thread la manipola strutturalmente allora è necessario renderla sincronizzata esternamente. Viene fatto sincronizzando alcuni oggetti che incapsulano la mappa. Se non esiste alcun oggetto di questo tipo, è possibile racchiuderlo in Collections.synchronizedMap() per sincronizzare HashMap ed evitare accessi accidentali non sincronizzati. Come nel seguente esempio:

Map m = Collections.synchronizedMap(new HashMap(...));>

Ora la Mappa m è sincronizzata. Gli iteratori di questa classe sono fail-fast se viene eseguita qualsiasi modifica alla struttura dopo la creazione dell'iteratore, in qualsiasi modo tranne che attraverso il metodo di rimozione dell'iteratore. In caso di fallimento di un iteratore, verrà lanciata ConcurrentModificationException.

Applicazioni di HashMap:

HashMap è principalmente l'implementazione dell'hashing. È utile quando abbiamo bisogno di un'implementazione efficiente delle operazioni di ricerca, inserimento ed eliminazione. Si prega di fare riferimento al applicazioni dell'hashing per dettagli.

Metodi in HashMapassociate

  • K – Il tipo delle chiavi nella mappa.
  • IN – Il tipo di valori mappati nella mappa.

Metodo

Descrizione

chiaro() Rimuove tutte le mappature da questa mappa.
clone() Restituisce una copia superficiale di questa istanza HashMap: le chiavi e i valori stessi non vengono clonati.
calcolo (tasto K, BiFunzione ? super V,? estende V> remappingFunction) Tenta di calcolare una mappatura per la chiave specificata e il relativo valore mappato corrente (o null se non è presente alcuna mappatura corrente).
computeIfAbsent(tasto K, funzione super K,? estende V> mappingFunction) Se la chiave specificata non è già associata a un valore (o è mappata su null), tenta di calcolarne il valore utilizzando la funzione di mappatura specificata e la inserisce in questa mappa a meno che non sia null.
computeIfPresent(tasto K, BiFunzione ? super V,? estende V> remappingFunction) Se il valore per la chiave specificata è presente e non nullo, tenta di calcolare una nuova mappatura in base alla chiave e al relativo valore mappato corrente.
contieneChiave(Chiave oggetto) Restituisce vero se questa mappa contiene una mappatura per la chiave specificata.
contieneValore(Valore oggetto) Restituisce vero se questa mappa mappa una o più chiavi al valore specificato.
set di voci() Restituisce una vista Set delle mappature contenute in questa mappa.
get(Chiave oggetto) Restituisce il valore a cui è mappata la chiave specificata oppure null se questa mappa non contiene alcuna mappatura per la chiave.
è vuoto() Restituisce vero se questa mappa non contiene mappature di valori-chiave.
mazzo di chiavi() Restituisce una vista Set delle chiavi contenute in questa mappa.
merge(tasto K, valore V, BiFunzione ? super V,? estende V> remappingFunction) Se la chiave specificata non è già associata a un valore o è associata a null, associala al valore non null specificato.
put(chiave K, valore V) Associa il valore specificato alla chiave specificata in questa mappa.
putAll(Mappa m) Copia tutte le mappature dalla mappa specificata a questa mappa.
rimuovi(chiave oggetto) Rimuove la mappatura per la chiave specificata da questa mappa, se presente.
misurare() Restituisce il numero di mappature di valori-chiave in questa mappa.
valori() Restituisce una vista Raccolta dei valori contenuti in questa mappa.

Metodi ereditati dalla classe java.util.AbstractMap

METODO

DESCRIZIONE

equivale()

Confronta l'oggetto specificato con questa mappa per verificarne l'uguaglianza.

codice hash()

booleano Java
Restituisce il valore del codice hash per questa mappa.

accordare()

Restituisce una rappresentazione di stringa di questa mappa.

Metodi ereditati dall'interfaccia java.util.Map

METODO

DESCRIZIONE

equivale() Confronta l'oggetto specificato con questa mappa per verificarne l'uguaglianza.

forEach(azione BiConsumer)

Esegue l'azione specificata per ogni voce in questa mappa finché tutte le voci non vengono elaborate o l'azione genera un'eccezione.
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.
codice hash() Restituisce il valore del codice hash per questa mappa.
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 corrente.
rimuovi(Chiave oggetto, Valore oggetto) Rimuove la voce per la chiave specificata solo se è attualmente mappata al valore specificato.
sostituisci (chiave K, valore V) Sostituisce la voce per la chiave specificata solo se è attualmente mappata su un valore.
sostituisci (chiave K, V vecchioValore, V nuovoValore) Sostituisce la voce per la chiave specificata solo se attualmente mappata al valore specificato.

sostituisci tutto (funzione BiFunzione)

Sostituisce il valore di ciascuna voce con il risultato dell'invocazione della funzione specificata su quella voce fino a quando tutte le voci non sono state elaborate o la funzione genera un'eccezione.

Vantaggi di Java HashMap

  • Recupero veloce: Le HashMap forniscono un accesso costante agli elementi, il che significa che il recupero e l'inserimento degli elementi è molto veloce.
  • Archiviazione efficiente : Gli HashMap utilizzano una funzione di hashing per mappare le chiavi sugli indici in un array. Ciò consente una rapida ricerca dei valori in base alle chiavi e un'archiviazione efficiente dei dati.
  • Flessibilità : HashMaps consente chiavi e valori nulli e può memorizzare coppie chiave-valore di qualsiasi tipo di dati.
  • Facile da usare : Gli HashMap hanno un'interfaccia semplice e possono essere facilmente implementati in Java.
  • Adatto per set di dati di grandi dimensioni : HashMaps può gestire set di dati di grandi dimensioni senza rallentamenti.

Svantaggi di Java HashMap

  • Non ordinato : Le HashMap non sono ordinate, il che significa che l'ordine in cui gli elementi vengono aggiunti alla mappa non viene preservato.
  • Non thread-safe : Gli HashMap non sono thread-safe, il che significa che se più thread accedono contemporaneamente alla stessa hashmap, ciò può portare a incoerenze nei dati.
  • Le prestazioni possono peggiorare : In alcuni casi, se la funzione di hashing non è implementata correttamente o se il fattore di carico è troppo elevato, le prestazioni di una HashMap possono peggiorare.
  • Più complesso di array o elenchi : Gli HashMap possono essere più complessi da comprendere e utilizzare rispetto a semplici array o elenchi, soprattutto per i principianti.
  • Maggiore utilizzo della memoria : Poiché gli HashMap utilizzano un array sottostante, possono utilizzare più memoria rispetto ad altre strutture dati come array o elenchi. Questo può essere uno svantaggio se l'utilizzo della memoria è un problema.
  • Hashmap vs Treemap
  • Hashmap contro HashTable
  • Articoli recenti su Java HashMap

Domande frequenti su Java HashMap

1. Cos'è una HashMap in Java?

HashMap in Java è la classe del framework di raccolta che può memorizzare coppie chiave-valore al suo interno.

2. Perché utilizzare HashMap in Java?

HashMap in Java viene utilizzato per memorizzare coppie chiave-valore in cui ciascuna chiave è univoca.

3. Qual è il vantaggio di HashMap?

HashMap viene utilizzato perché fornisce funzionalità come:

  • Recupero veloce
  • Archiviazione efficiente
  • Flessibile da usare
  • Facile da usare
  • Adatto per set di dati di grandi dimensioni