În Java, HashMap face parte din colecția Java începând cu Java 1.2. Această clasă se găsește în java.util pachet. Acesta oferă implementarea de bază a interfeței Map din Java. HashMap în Java stochează datele în perechi (cheie, valoare) și le puteți accesa printr-un index de alt tip (de exemplu, un număr întreg). Un obiect este folosit ca cheie (index) pentru un alt obiect (valoare). Dacă încercați să introduceți cheia duplicată în HashMap, aceasta va înlocui elementul cheii corespunzătoare.
Ce este HashMap?
Java HashMap este asemănător cu HashTable , dar este nesincronizat. Permite și stocarea cheilor nule, dar ar trebui să existe un singur obiect cheie nulă și poate exista orice număr de valori nule. Această clasă nu oferă garanții cu privire la ordinea hărții. Pentru a utiliza această clasă și metodele sale, trebuie să importați java.util.HashMap pachet sau superclasa acestuia.
Cuprins
- Ce este HashMap?
- Exemple Java HashMap
- Declarație HashMap
- Ierarhia Java HashMap
- Crearea HashMap în Java
- Constructori Java HashMap
- Efectuarea diferitelor operații pe HashMap
- Complexitatea HashMap în Java
- Structura internă a HashMap
- Avantajele și dezavantajele Java HashMap
Exemple Java HashMap
Mai jos este implementarea unui exemplu de Java HashMap:
Java
diferența dintre leu și tigru
// 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);> >}> >}> }> |
>
>Ieșire
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap Declaraţie
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametri:
Este nevoie de doi parametri și anume după cum urmează:
- Tipul de chei menținute de această hartă
- Tipul de valori mapate
Notă: K ochii și valoarea nu pot fi tipul de date primitiv. Cheia în Hashmap este validă dacă se implementează hashCode() și metoda equals(). , ar trebui să fie, de asemenea, imuabil (obiect personalizat imuabil), astfel încât codul hash și egalitatea să rămână constante. Valoarea în hashmap poate fi orice clasă wrapper, obiecte personalizate, matrice, orice tip de referință sau chiar null.
De exemplu : Hashmap poate avea matrice ca valoare, dar nu ca cheie.
HashMap în implementări Java Serializabil , Clonabil , Hartă interfețe.Java HashMap se extinde AbstractHarta clasă. Subclasele directe sunt LinkedHashMap și PrinterStateReasons .
Ierarhia Java HashMap
Caracteristicile Java HashMap
Un HashMap este o structură de date care este utilizată pentru a stoca și a prelua valori bazate pe chei. Unele dintre caracteristicile cheie ale unei hărți hash includ:
- Timp de acces rapid : HashMaps oferă acces constant în timp la elemente, ceea ce înseamnă că regăsirea și inserarea elementelor sunt foarte rapide, de obicei O(1) complexitate în timp.
- Utilizează funcția de hashing : HashMaps folosește o funcție hash pentru a mapa cheile la indici dintr-o matrice. Acest lucru permite o căutare rapidă a valorilor bazate pe chei.
- Stochează perechi cheie-valoare: Fiecare element dintr-un HashMap este format dintr-o pereche cheie-valoare. Cheia este folosită pentru a căuta valoarea asociată.
- Suportă chei și valori nule : HashMaps permit valori și chei nule. Aceasta înseamnă că o cheie nulă poate fi utilizată pentru a stoca o valoare, iar o valoare nulă poate fi asociată cu o cheie.
- Necomandat: HashMaps nu sunt ordonate, ceea ce înseamnă că ordinea în care elementele sunt adăugate pe hartă nu este păstrată. Cu toate acestea, LinkedHashMap este o variantă a lui HashMap care păstrează ordinea de inserare.
- Permite duplicate : HashMaps permit valori duplicate, dar nu chei duplicate. Dacă se adaugă o cheie duplicată, valoarea anterioară asociată cheii este suprascrisă.
- Fire nesigure : HashMaps nu sunt sigure pentru fire, ceea ce înseamnă că dacă mai multe fire accesează simultan aceeași hashmap, poate duce la inconsecvențe de date. Dacă este necesară siguranța firelor, ConcurrentHashMap poate fi utilizat.
- Capacitate și factor de sarcină : HashMaps au o capacitate, care este numărul de elemente pe care le poate stoca, și un factor de încărcare, care este măsura cât de plină poate fi hashmap-ul înainte de a fi redimensionat.
Crearea HashMap în Java
Să înțelegem cum putem crea HashMap în Java cu un exemplu menționat mai jos:
Java
// 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> >}> }> |
>
>Ieșire
25 false 2>
Constructori Java HashMap
HashMap oferă 4 constructori, iar modificatorul de acces al fiecăruia este public, care sunt enumerați după cum urmează:
- HashMap()
- HashMap(int initialCapacity)
- HashMap (int initialCapacity, float loadFactor)
- HashMap (Hartă hartă)
Acum discutăm unul câte unul despre constructorii de mai sus împreună cu implementarea acelorași cu ajutorul programelor Java curate.
1. HashMap()
Este constructorul implicit care creează o instanță de HashMap cu o capacitate inițială de 16 și un factor de încărcare de 0,75.
Sintaxă:
HashMap hm = new HashMap();>
Exemplu
Java
// 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);> >}> }> |
>
>Ieșire
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 initialCapacity)
Acesta creează o instanță HashMap cu a capacitatea inițială specificată și factorul de sarcină de 0,75.
Sintaxă:
HashMap hm = new HashMap(int initialCapacity);>
Exemplu
Java
tutorial .net
// 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);> >}> }> |
>
>Ieșire
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 initialCapacity, float loadFactor)
Acesta creează o instanță HashMap cu o capacitate inițială specificată și un factor de încărcare specificat.
Sintaxă:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Exemplu
Java
// 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);> >}> }> |
>
>Ieșire
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (Hartă hartă)
Acesta creează o instanță de HashMap cu aceleași mapări ca și harta specificată.
HashMap hm = new HashMap(Hartă Hartă);
Java
// 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);> >}> }> |
>
>Ieșire
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Efectuarea diferitelor operații pe HashMap
1. Adăugarea de elemente în HashMap în Java
Pentru a adăuga un element pe hartă, putem folosi a pune() metodă. Cu toate acestea, ordinea de inserare nu este reținută în Hashmap. Intern, pentru fiecare element, este generat un hash separat, iar elementele sunt indexate pe baza acestui hash pentru a-l face mai eficient.
Java
// 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);> >}> }> |
>
>Ieșire
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Schimbarea elementelor în HashMap în Java
După adăugarea elementelor, dacă dorim să schimbăm elementul, se poate face prin adăugarea din nou a elementului cu a pune() metodă. Deoarece elementele din hartă sunt indexate cu ajutorul tastelor, valoarea cheii poate fi modificată prin simpla inserare a valorii actualizate pentru cheia pentru care dorim să o modificăm.
Java
// 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);> >}> }> |
>
>Ieșire
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Eliminarea elementului din Java HashMap
Pentru a elimina un element din Hartă, putem folosi elimina() metodă. Această metodă preia valoarea cheii și elimină maparea pentru o cheie de pe această hartă dacă aceasta este prezentă pe hartă.
Java
// 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);> >}> }> |
>
>Ieșire
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Traversarea Java HashMap
Putem folosi interfața Iterator pentru a parcurge orice structură a cadrului de colectare. Deoarece iteratorii lucrează cu un singur tip de date, folosim Entry pentru a rezolva cele două tipuri separate într-un format compatibil. Apoi, folosind metoda next() imprimăm intrările din HashMap.
Java
lista de inițializare python
// 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());> >}> }> |
>
>Ieșire
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
Complexitatea HashMap în Java
HashMap oferă o complexitate constantă în timp pentru operațiunile de bază, obțineți și puneți dacă funcția hash este scrisă corect și dispersează elementele în mod corespunzător printre găleți. Iterația peste HashMap depinde de capacitatea HashMap și de numărul de perechi cheie-valoare. Practic, este direct proportional cu capacitatea + dimensiunea. Capacitatea este numărul de găleți din HashMap. Deci nu este o idee bună să păstrați inițial un număr mare de găleți în HashMap.
| Metode | Complexitatea timpului | Complexitatea spațială |
|---|---|---|
| Adăugarea de elemente în HashMap | O(1) | PE) |
| Eliminarea elementului din HashMap | O(1) | PE) |
| Extragerea elementului din Java | O(1) | PE) |
Caracteristici importante ale HashMap
Pentru a accesa o valoare trebuie să-i cunoști cheia. HashMap este cunoscut ca HashMap deoarece folosește o tehnică numită Hashing. Hashing este o tehnică de conversie a unui șir mare într-un șir mic care reprezintă același șir. O valoare mai scurtă ajută la indexare și la căutări mai rapide. HashSet folosește și HashMap intern.
Câteva caracteristici importante ale HashMap sunt:
- HashMap este o parte a pachetului java.util.
- HashMap extinde o clasă abstractă AbstractMap care oferă, de asemenea, o implementare incompletă a interfeței Map.
- De asemenea, implementează a Clonabil și Serializabil interfețe. K și V în definiția de mai sus reprezintă cheia și respectiv valoarea.
- HashMap nu permite chei duplicate, dar permite valori duplicate. Aceasta înseamnă că o singură cheie nu poate conține mai mult de o valoare, dar mai mult de o cheie poate conține o singură valoare.
- HashMap permite și o cheie nulă, dar o singură dată și mai multe valori nule.
- Această clasă nu oferă garanții cu privire la ordinea hărții; în special, nu garantează că comanda va rămâne constantă în timp. Este aproximativ similar cu HashTable, dar este nesincronizat.
Structura internă a HashMap
Intern HashMap conține o matrice de Node și un nod este reprezentat ca o clasă care conține 4 câmpuri:
- int hash
- Tasta K
- Valoarea V
- Nodul următor
Se poate observa că nodul conține o referință la propriul obiect. Deci este o listă legată.
HashMap:
Nodul:
cum să inițializați o matrice în java
Performanța HashMap
Performanța HashMap depinde de 2 parametri care sunt denumiți după cum urmează:
- Capacitatea initiala
- Factor de încărcare
1. Capacitatea initiala – Este capacitatea HashMap la momentul creării sale (este numărul de găleți pe care un HashMap le poate deține atunci când HashMap este instanțiat). În java, inițial este 2^4=16, ceea ce înseamnă că poate conține 16 perechi cheie-valoare.
2. Factorul de sarcină – Este valoarea procentuală a capacității după care trebuie crescută capacitatea Hashmap (este procentul de umplere a găleților după care are loc Rehashing). În java, este 0.75f în mod implicit, ceea ce înseamnă că rehashingul are loc după umplerea a 75% din capacitate.
3. Prag – Este produsul factorului de sarcină și capacității inițiale. În java, implicit, este (16 * 0,75 = 12). Adică, rehashingul are loc după inserarea a 12 perechi cheie-valoare în HashMap.
4. Rehashing – Este procesul de dublare a capacității HashMap-ului după ce acesta își atinge Pragul. În java, HashMap continuă să rehash (în mod implicit) în următoarea secvență – 2^4, 2^5, 2^6, 2^7, …. curând.
Dacă capacitatea inițială este menținută mai mare, atunci rehashing nu se va face niciodată. Dar, menținând-o mai mare, crește complexitatea de timp a iterației. Deci ar trebui ales foarte inteligent pentru a crește performanța. Numărul așteptat de valori ar trebui să fie luat în considerare pentru a seta capacitatea inițială. Valoarea factorului de sarcină preferată în general este 0,75, ceea ce oferă o bună parte între costurile de timp și spațiu. Valoarea factorului de sarcină variază între 0 și 1.
Notă: De la Java 8 încolo, Java a început să folosească Self Balancing BST în loc de o listă legată pentru înlănțuire. Avantajul auto-echilibrării bst este că în cel mai rău caz (când fiecare cheie se mapează la același slot) timpul de căutare este O(Log n).
HashMap sincronizat
După cum se spune că HashMap este nesincronizat, adică mai multe fire îl pot accesa simultan. Dacă mai multe fire accesează această clasă simultan și cel puțin un fir o manipulează structural, atunci este necesar să o faceți sincronizată extern. Se realizează prin sincronizarea unui obiect care încapsulează harta. Dacă nu există un astfel de obiect, atunci acesta poate fi înfășurat în jurul Collections.synchronizedMap() pentru a face HashMap sincronizat și pentru a evita accesul accidental nesincronizat. Ca în exemplul următor:
Map m = Collections.synchronizedMap(new HashMap(...));>
Acum Harta m este sincronizată. Iteratoarele din această clasă sunt rapide dacă se face orice modificare a structurii după crearea iteratorului, în orice mod, cu excepția metodei de eliminare a iteratorului. În cazul eșecului unui iterator, acesta va arunca ConcurrentModificationException.
Aplicații HashMap:
HashMap este în principal implementarea hashing-ului. Este util atunci când avem nevoie de implementare eficientă a operațiunilor de căutare, inserare și ștergere. Vă rugăm să consultați aplicații de hashing pentru detalii.
Metode în HashMapassociate
- K – Tipul cheilor din hartă.
- ÎN – Tipul de valori mapate în hartă.
| Metodă | Descriere |
|---|---|
| clar() | Elimină toate mapările de pe această hartă. |
| clona() | Returnează o copie superficială a acestei instanțe HashMap: cheile și valorile în sine nu sunt clonate. |
| calculează (tasta K, BiFunction ? super V,? extinde V> remappingFunction) | Încearcă să calculeze o mapare pentru cheia specificată și valoarea sa mapată curentă (sau nulă dacă nu există o mapare curentă). |
| computeIfAbsent (tasta K, Funcție super K,? extinde V> mappingFunction) | Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null), încearcă să-și calculeze valoarea utilizând funcția de mapare dată și o introduce în această hartă, dacă nu este nulă. |
| computeIfPresent(tasta K, BiFunction ? super V,? extinde V> remappingFunction) | Dacă valoarea pentru cheia specificată este prezentă și nu este nulă, încearcă să calculeze o nouă mapare având în vedere cheia și valoarea ei actuală mapată. |
| containsKey(cheie obiect) | Returnează true dacă această hartă conține o mapare pentru cheia specificată. |
| containsValue(Valoare obiect) | Returnează true dacă această hartă mapează una sau mai multe chei la valoarea specificată. |
| entrySet() | Returnează o vizualizare Set a mapărilor conținute în această hartă. |
| get(cheie obiect) | Returnează valoarea la care este mapată cheia specificată sau nulă dacă această hartă nu conține nicio mapare pentru cheie. |
| este gol() | Returnează true dacă această hartă nu conține mapări cheie-valoare. |
| keySet() | Returnează o vizualizare Set a cheilor conținute în această hartă. |
| merge (tasta K, valoarea V, BiFunction ? super V,? extinde V> remappingFunction) | Dacă cheia specificată nu este deja asociată cu o valoare sau este asociată cu null, asociați-o cu valoarea non-nulă dată. |
| pune (tasta K, valoarea V) | Asociază valoarea specificată cu cheia specificată în această hartă. |
| putAll(Harta m) | Copiază toate mapările de pe harta specificată pe această hartă. |
| eliminați (cheia obiectului) | Elimină maparea pentru cheia specificată de pe această hartă, dacă este prezentă. |
| mărimea() | Returnează numărul de mapări cheie-valoare din această hartă. |
| valori () | Returnează o vizualizare de colecție a valorilor conținute în această hartă. |
Metode moștenite din clasa java.util.AbstractMap
| METODĂ | DESCRIERE |
|---|---|
| este egal() | Compară obiectul specificat cu această hartă pentru egalitate. |
| hashCode() | Returnează valoarea codului hash pentru această hartă. |
| toString() | Returnează o reprezentare șir a acestei hărți. |
Metode moștenite de la interfața java.util.Map
| METODĂ | DESCRIERE |
|---|---|
| este egal() | Compară obiectul specificat cu această hartă pentru egalitate. |
| forEach (acțiune BiConsumer) | Efectuează acțiunea dată pentru fiecare intrare din această hartă până când toate intrările au fost procesate sau acțiunea aruncă o excepție. |
| getOrDefault(cheia obiectului, V defaultValue) | Returnează valoarea la care este mapată cheia specificată sau defaultValue dacă această hartă nu conține nicio mapare pentru cheie. |
| hashCode() | Returnează valoarea codului hash pentru această hartă. |
| putIfAbsent (cheia K, valoarea V) | Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null) o asociază cu valoarea dată și returnează null, altfel returnează valoarea curentă. |
| eliminați (cheia obiectului, valoarea obiectului) | Elimină intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată. |
| înlocuiți (tasta K, valoarea V) | Înlocuiește intrarea pentru cheia specificată numai dacă este mapată în prezent la o anumită valoare. |
| înlocuiți (tasta K, V vecheValoare, V nouăValoare) | Înlocuiește intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată. |
| replaceAll (funcția BiFunction) | Înlocuiește valoarea fiecărei intrări cu rezultatul invocării funcției date pe acea intrare până când toate intrările au fost procesate sau funcția aruncă o excepție. |
Avantajele Java HashMap
- Recuperare rapidă: HashMaps oferă acces constant în timp la elemente, ceea ce înseamnă că regăsirea și inserarea elementelor este foarte rapidă.
- Depozitare eficientă : HashMaps utilizează o funcție de hashing pentru a mapa cheile la indici dintr-o matrice. Acest lucru permite căutarea rapidă a valorilor bazate pe chei și stocarea eficientă a datelor.
- Flexibilitate : HashMaps permit chei și valori nule și pot stoca perechi cheie-valoare de orice tip de date.
- Ușor de folosit : HashMaps au o interfață simplă și pot fi implementate cu ușurință în Java.
- Potrivit pentru seturi mari de date : HashMaps poate gestiona seturi mari de date fără a încetini.
Dezavantajele Java HashMap
- Neordonat : HashMaps-urile nu sunt ordonate, ceea ce înseamnă că ordinea în care elementele sunt adăugate pe hartă nu este păstrată.
- Nu este sigură pentru fire : HashMaps nu sunt sigure pentru fire, ceea ce înseamnă că dacă mai multe fire accesează simultan aceeași hashmap, poate duce la inconsecvențe de date.
- Performanța se poate degrada : În unele cazuri, dacă funcția de hashing nu este implementată corect sau dacă factorul de încărcare este prea mare, performanța unui HashMap se poate degrada.
- Mai complex decât matricele sau listele : HashMaps poate fi mai complex de înțeles și utilizat decât simple matrice sau liste, în special pentru începători.
- Utilizare mai mare a memoriei : Deoarece HashMaps utilizează o matrice subiacentă, pot folosi mai multă memorie decât alte structuri de date, cum ar fi matrice sau liste. Acest lucru poate fi un dezavantaj dacă utilizarea memoriei este o problemă.
De asemenea, Citeste
- Hashmap vs Treemap
- Hashmap vs HashTable
- Articole recente pe Java HashMap
Întrebări frecvente despre Java HashMap
1. Ce este un HashMap în Java?
HashMap în Java este clasa din cadrul de colecție care poate stoca perechi cheie-valoare în interiorul acesteia.
2. De ce să folosiți HashMap în Java?
HashMap în Java este folosit pentru stocarea perechilor cheie-valoare în care fiecare cheie este unică.
3. Care este beneficiul HashMap?
HashMap este utilizat deoarece oferă caracteristici precum:
- Recuperare rapidă
- Depozitare eficientă
- Flexibil de utilizat
- Ușor de folosit
- Potrivit pentru seturi mari de date