V jazyku Java, HashMap je súčasťou kolekcie Java od verzie Java 1.2. Táto trieda sa nachádza v java.util balík. Poskytuje základnú implementáciu mapového rozhrania Java. HashMap v jazyku Java ukladá údaje do párov (Kľúč, Hodnota) a môžete k nim pristupovať pomocou indexu iného typu (napr. Integer). Jeden objekt sa používa ako kľúč (index) k inému objektu (hodnote). Ak sa pokúsite vložiť duplicitný kľúč do HashMap, nahradí prvok zodpovedajúceho kľúča.
Čo je HashMap?
Java HashMap je podobný HashTable , ale nie je synchronizovaný. Umožňuje uložiť aj nulové kľúče, ale mal by existovať iba jeden objekt nulového kľúča a môže existovať ľubovoľný počet hodnôt null. Táto trieda neposkytuje žiadne záruky, pokiaľ ide o poradie mapy. Ak chcete použiť túto triedu a jej metódy, musíte importovať java.util.HashMap balík alebo jeho nadtriedu.
Obsah
- Čo je HashMap?
- Príklady Java HashMap
- Vyhlásenie HashMap
- Hierarchia Java HashMap
- Vytvorenie HashMap v Jave
- Konštruktory Java HashMap
- Vykonávanie rôznych operácií na HashMap
- Zložitosť HashMap v Jave
- Vnútorná štruktúra HashMap
- Výhody a nevýhody Java HashMap
Príklady Java HashMap
Nižšie je uvedená implementácia príkladu Java HashMap:
Java
// 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);> >}> >}> }> |
>
>Výkon
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap Vyhlásenie
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametre:
Vyžaduje si dva parametre, konkrétne takto:
- Typ kľúčov udržiavaných touto mapou
- Typ mapovaných hodnôt
Poznámka: K ey a value nemôžu byť primitívnym dátovým typom. Kľúč v Hashmap je platný, ak je implementovaný metódy hashCode() a equals(). , mal by byť tiež nemenný (nezmeniteľný vlastný objekt), aby kód hash a rovnosť zostali konštantné. Hodnota v hashmap môže byť ľubovoľná trieda obalu, vlastné objekty, polia, akýkoľvek typ odkazu alebo dokonca null .
Napríklad : Hashmap môže mať pole ako hodnotu, ale nie ako kľúč.
HashMap v implementáciách Java Serializovateľné , Klonovateľné , Mapa rozhrania.Java HashMap rozširuje Abstraktná mapa trieda. Priame podtriedy sú LinkedHashMap a PrinterStateReasons .
Hierarchia Java HashMap

Charakteristika Java HashMap
HashMap je dátová štruktúra, ktorá sa používa na ukladanie a získavanie hodnôt na základe kľúčov. Niektoré z kľúčových charakteristík hashmap zahŕňajú:
- Rýchly prístupový čas : HashMaps poskytujú neustály časový prístup k prvkom, čo znamená, že vyhľadávanie a vkladanie prvkov je veľmi rýchle, zvyčajne O(1) časová zložitosť.
- Používa funkciu hashovania : HashMaps používa hašovaciu funkciu na mapovanie kľúčov na indexy v poli. To umožňuje rýchle vyhľadávanie hodnôt na základe kľúčov.
- Ukladá páry kľúč – hodnota: Každý prvok v HashMape pozostáva z páru kľúč – hodnota. Kľúč sa používa na vyhľadanie súvisiacej hodnoty.
- Podporuje nulové kľúče a hodnoty : HashMaps umožňujú nulové hodnoty a kľúče. To znamená, že na uloženie hodnoty možno použiť nulový kľúč a ku kľúču možno priradiť nulovú hodnotu.
- Nie je objednané: HashMapy nie sú usporiadané, čo znamená, že poradie, v ktorom sú prvky pridávané do mapy, nie je zachované. LinkedHashMap je však variáciou HashMap, ktorá zachováva poradie vloženia.
- Umožňuje duplikáty : HashMaps umožňujú duplicitné hodnoty, ale nie duplicitné kľúče. Ak sa pridá duplicitný kľúč, predchádzajúca hodnota priradená ku kľúču sa prepíše.
- Niť-nebezpečné : HashMaps nie sú bezpečné pre vlákna, čo znamená, že ak k rovnakej hashmape pristupuje viacero vlákien súčasne, môže to viesť k nekonzistentnosti údajov. Ak sa vyžaduje bezpečnosť vlákien, možno použiť ConcurrentHashMap.
- Kapacita a koeficient zaťaženia : HashMapy majú kapacitu, čo je počet prvkov, ktoré môžu obsahovať, a faktor zaťaženia, čo je miera toho, ako plná môže byť hashmapa pred zmenou veľkosti.
Vytvorenie HashMap v Jave
Poďme pochopiť, ako môžeme vytvoriť HashMap v Jave s príkladom uvedeným nižšie:
Java
je prázdna 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> >}> }> |
>
>Výkon
25 false 2>
Konštruktory Java HashMap
HashMap poskytuje 4 konštruktory a modifikátor prístupu každého z nich je verejný, ktoré sú uvedené takto:
- HashMap()
- HashMap (int initialCapacity)
- HashMap(int initialCapacity, float loadFactor)
- HashMap (mapa mapy)
Teraz diskutujeme o vyššie uvedených konštruktéroch jeden po druhom spolu s ich implementáciou pomocou čistých programov Java.
1. HashMap()
Je to predvolený konštruktor, ktorý vytvára inštanciu HashMap s počiatočnou kapacitou 16 a faktorom zaťaženia 0,75.
Syntax:
HashMap hm = new HashMap();>
Príklad
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);> >}> }> |
>
>Výkon
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)
Vytvára inštanciu HashMap s a špecifikovaná počiatočná kapacita a koeficient zaťaženia 0,75.
Syntax:
HashMap hm = new HashMap(int initialCapacity);>
Príklad
Java
// 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);> >}> }> |
>
>Výkon
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)
Vytvára inštanciu HashMap so špecifikovanou počiatočnou kapacitou a špecifikovaným faktorom zaťaženia.
Syntax:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Príklad
Java
skúste catch catch 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);> >}> }> |
>
>Výkon
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (mapa mapy)
Vytvorí inštanciu HashMap s rovnakým mapovaním ako zadaná mapa.
HashMap hm = new HashMap (mapa mapy);
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);> >}> }> |
>
>Výkon
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Vykonávanie rôznych operácií na HashMap
1. Pridávanie prvkov v HashMap v Jave
Na pridanie prvku do mapy môžeme použiť dať () metóda. Poradie vloženia sa však v Hashmap nezachová. Interne sa pre každý prvok vygeneruje samostatný hash a prvky sa indexujú na základe tohto hashu, aby bol efektívnejší.
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);> >}> }> |
>
>Výkon
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Zmena prvkov v HashMap v Jave
Po pridaní prvkov, ak chceme prvok zmeniť, môžeme to urobiť opätovným pridaním prvku s dať () metóda. Keďže prvky na mape sú indexované pomocou kľúčov, hodnotu kľúča je možné zmeniť jednoduchým vložením aktualizovanej hodnoty pre kľúč, ktorý chceme zmeniť.
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);> >}> }> |
>
>
výnimka java throwVýkon
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Odstránenie prvku z Java HashMap
Na odstránenie prvku z mapy môžeme použiť odstrániť () metóda. Táto metóda prevezme hodnotu kľúča a odstráni mapovanie pre kľúč z tejto mapy, ak sa na mape nachádza.
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);> >}> }> |
>
>Výkon
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Prechod Java HashMap
Rozhranie Iterator môžeme použiť na prechádzanie cez akúkoľvek štruktúru Collection Framework. Keďže iterátory pracujú s jedným typom údajov, používame Entry na rozlíšenie dvoch samostatných typov do kompatibilného formátu. Potom pomocou metódy next() vytlačíme položky HashMap.
Java
// 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());> >}> }> |
>
>Výkon
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
Zložitosť HashMap v Jave
HashMap poskytuje konštantnú časovú zložitosť pre základné operácie, získajte a vložte, ak je hašovacia funkcia správne napísaná a správne rozdeľuje prvky medzi vedrá. Iterácia cez HashMap závisí od kapacity HashMap a počtu párov kľúč – hodnota. V podstate je to priamo úmerné kapacite + veľkosti. Kapacita je počet bucketov v HashMap. Preto nie je dobrý nápad ponechať si na začiatku v HashMape vysoký počet vedier.
| Metódy | Časová zložitosť | Priestorová zložitosť |
|---|---|---|
| Pridávanie prvkov do HashMap | O(1) | O(N) |
| Odstránenie prvku z HashMap | O(1) | O(N) |
| Extrahovanie prvku z Java | O(1) | O(N) |
Dôležité funkcie HashMap
Ak chcete získať prístup k hodnote, musíte poznať jej kľúč. HashMap je známa ako HashMap, pretože používa techniku nazývanú hashovanie. Hašovanie je technika konverzie veľkého reťazca na malý reťazec, ktorý predstavuje rovnaký reťazec. Kratšia hodnota pomáha pri indexovaní a rýchlejšie vyhľadávanie. HashSet tiež interne používa HashMap.
Niekoľko dôležitých funkcií HashMap je:
- HashMap je súčasťou balíka java.util.
- HashMap rozširuje abstraktnú triedu AbstractMap, ktorá tiež poskytuje neúplnú implementáciu rozhrania mapy.
- Taktiež implementuje a Klonovateľné a Serializovateľné rozhrania. K a V vo vyššie uvedenej definícii predstavujú kľúč a hodnotu.
- HashMap nepovoľuje duplicitné kľúče, ale umožňuje duplicitné hodnoty. To znamená, že jeden kľúč nemôže obsahovať viac ako 1 hodnotu, ale viac ako 1 kľúč môže obsahovať jednu hodnotu.
- HashMap umožňuje aj nulový kľúč, ale iba raz a viac hodnôt null.
- Táto trieda neposkytuje žiadne záruky, pokiaľ ide o poradie mapy; najmä nezaručuje, že poradie zostane v priebehu času konštantné. Je zhruba podobný HashTable, ale je nesynchronizovaný.
Vnútorná štruktúra HashMap
Interne HashMap obsahuje pole Node a uzol je reprezentovaný ako trieda, ktorá obsahuje 4 polia:
- int hash
- K kľúč
- hodnota V
- Ďalej uzol
Je vidieť, že uzol obsahuje odkaz na svoj vlastný objekt. Ide teda o prepojený zoznam.
HashMap:

uzol:
c# dátum a čas

Výkon HashMap
Výkon HashMap závisí od 2 parametrov, ktoré sú pomenované takto:
- Počiatočná kapacita
- Vyťaženosť
1. Počiatočná kapacita – Je to kapacita HashMap v čase jej vytvorenia (Je to počet segmentov, ktoré môže HashMap obsahovať, keď je HashMap inštanciovaná). V jazyku Java je na začiatku 2^4=16, čo znamená, že môže obsahovať 16 párov kľúč – hodnota.
2. Faktor zaťaženia – Je to percentuálna hodnota kapacity, po ktorej sa má kapacita Hashmap zvýšiť (Je to percentuálne naplnenie bucketov, po ktorých prebehne Rehashing). V jave je to štandardne 0,75f, čo znamená, že prehashovanie sa uskutoční po naplnení 75% kapacity.
3. Prahová hodnota – Je to súčin faktora zaťaženia a počiatočnej kapacity. V jave je to štandardne (16 * 0,75 = 12). To znamená, že rehashing sa uskutoční po vložení 12 párov kľúč – hodnota do HashMap.
4. Rehashing – Je to proces zdvojnásobenia kapacity HashMap po dosiahnutí svojho prahu. V jave HashMap pokračuje v prehadzovaní (predvolene) v nasledujúcom poradí – 2^4, 2^5, 2^6, 2^7, .... tak ďalej.
Ak sa počiatočná kapacita udrží na vyššej úrovni, prehánanie sa nikdy nevykoná. Ale jej udržaním sa zvyšuje časová náročnosť iterácie. Pre zvýšenie výkonu ho teda treba zvoliť veľmi šikovne. Pri stanovení počiatočnej kapacity by sa mal brať do úvahy očakávaný počet hodnôt. Najbežnejšie preferovaná hodnota faktora zaťaženia je 0,75, čo predstavuje dobrý pomer medzi nákladmi na čas a priestor. Hodnota faktora zaťaženia sa pohybuje medzi 0 a 1.
Poznámka: Od verzie Java 8 začala Java na reťazenie používať Self Balancing BST namiesto prepojeného zoznamu. Výhodou samovyvažovacieho bst je, že v najhoršom prípade (keď sa každý kľúč mapuje do rovnakého slotu) dostaneme čas vyhľadávania O(Log n).
Synchronizovaná HashMap
Ako sa hovorí, HashMap je nesynchronizovaná, t.j. viaceré vlákna k nej môžu pristupovať súčasne. Ak k tejto triede pristupuje viacero vlákien súčasne a aspoň jedno s ňou štrukturálne manipuluje, je potrebné ju externe synchronizovať. Robí sa to synchronizáciou nejakého objektu, ktorý zapuzdruje mapu. Ak žiadny takýto objekt neexistuje, môže byť zabalený okolo Collections.synchronizedMap(), aby sa HashMap synchronizoval a zabránilo sa náhodnému nesynchronizovanému prístupu. Ako v nasledujúcom príklade:
Map m = Collections.synchronizedMap(new HashMap(...));>
Teraz je mapa m synchronizovaná. Iterátory tejto triedy sú rýchle, ak sa po vytvorení iterátora vykoná akákoľvek úprava štruktúry, a to akýmkoľvek spôsobom okrem metódy odstránenia iterátora. V prípade zlyhania iterátora vyvolá výnimku ConcurrentModificationException.
Aplikácie HashMap:
HashMap je hlavne implementácia hashovania. Je to užitočné, keď potrebujeme efektívnu implementáciu operácií vyhľadávania, vkladania a odstraňovania. Pozrite si prosím aplikácie hashovania pre podrobnosti.
Metódy v HashMapassociate
- K – Typ kľúčov na mape.
- V – Typ hodnôt mapovaných na mape.
| Metóda | Popis |
|---|---|
| jasný() | Odstráni všetky mapovania z tejto mapy. |
| klon() | Vráti plytkú kópiu tejto inštancie HashMap: samotné kľúče a hodnoty nie sú klonované. |
| compute (kláves K, BiFunction ? super V,? rozširuje V> remappingFunction) | Pokúsi sa vypočítať mapovanie pre zadaný kľúč a jeho aktuálnu mapovanú hodnotu (alebo null, ak neexistuje žiadne aktuálne mapovanie). |
| computeIfAbsent(kláves K, funkcia super K,? rozširuje V> mappingFunction) | Ak zadaný kľúč ešte nie je priradený k hodnote (alebo je namapovaný na hodnotu null), pokúsi sa vypočítať jeho hodnotu pomocou danej mapovacej funkcie a vloží ju do tejto mapy, pokiaľ nie je nulová. |
| computeIfPresent (kláves K, BiFunction ? super V,? rozširuje V> remappingFunction) | Ak je hodnota zadaného kľúča prítomná a nie je nulová, pokúsi sa vypočítať nové mapovanie vzhľadom na kľúč a jeho aktuálnu namapovanú hodnotu. |
| obsahuje kľúč (kľúč objektu) | Vráti hodnotu true, ak táto mapa obsahuje mapovanie pre zadaný kľúč. |
| obsahujeValue(hodnota objektu) | Vráti hodnotu true, ak táto mapa mapuje jeden alebo viac kľúčov na zadanú hodnotu. |
| entrySet() | Vráti zobrazenie Nastaviť mapovania obsiahnuté v tejto mape. |
| get (kľúč objektu) | Vráti hodnotu, na ktorú je zadaný kľúč namapovaný, alebo hodnotu null, ak táto mapa neobsahuje žiadne mapovanie pre kľúč. |
| je prázdny() | Vráti hodnotu true, ak táto mapa neobsahuje žiadne mapovania párov kľúč – hodnota. |
| keySet() | Vráti zobrazenie Set kľúčov obsiahnutých v tejto mape. |
| zlúčenie (kľúč K, hodnota V, BiFunction ? super V,? rozširuje V> remappingFunction) | Ak zadaný kľúč ešte nie je priradený k hodnote alebo je priradený k hodnote null, priraďte ho k danej nenulovej hodnote. |
| put (kľúč K, hodnota V) | Priradí zadanú hodnotu k zadanému kľúču v tejto mape. |
| dať všetko (mapa m) | Skopíruje všetky mapovania zo zadanej mapy do tejto mapy. |
| odstrániť (kľúč objektu) | Odstráni mapovanie pre zadaný kľúč z tejto mapy, ak existuje. |
| veľkosť () | Vráti počet mapovaní kľúč – hodnota v tejto mape. |
| hodnoty() | Vráti zobrazenie kolekcie hodnôt obsiahnutých v tejto mape. |
Metódy zdedené z triedy java.util.AbstractMap
| METÓDA | POPIS |
|---|---|
| rovná sa() | Porovná zadaný objekt s touto mapou na dosiahnutie rovnosti. |
| hashCode() | Vráti hodnotu hash kódu pre túto mapu. |
| natiahnuť() | Vráti reťazcovú reprezentáciu tejto mapy. |
Metódy zdedené z rozhrania java.util.Map
| METÓDA | POPIS |
|---|---|
| rovná sa() | Porovná zadaný objekt s touto mapou na dosiahnutie rovnosti. |
| pre každého (akcia pre dvoch spotrebiteľov) | Vykoná danú akciu pre každý záznam na tejto mape, kým nie sú spracované všetky záznamy alebo kým akcia nevyvolá výnimku. |
| getOrDefault (kľúč objektu, V predvolená hodnota) | Vráti hodnotu, na ktorú je zadaný kľúč namapovaný, alebo defaultValue, ak táto mapa neobsahuje žiadne mapovanie pre kľúč. |
| hashCode() | Vráti hodnotu hash kódu pre túto mapu. |
| putIfAbsent (kľúč K, hodnota V) | Ak zadaný kľúč ešte nie je priradený k hodnote (alebo je namapovaný na hodnotu null), priradí ho k danej hodnote a vráti hodnotu null, inak vráti aktuálnu hodnotu. |
| odstrániť (kľúč objektu, hodnota objektu) | Odstráni položku pre zadaný kľúč len vtedy, ak je aktuálne namapovaný na zadanú hodnotu. |
| nahradiť (kľúč K, hodnota V) | Nahradí záznam pre zadaný kľúč iba vtedy, ak je momentálne namapovaný na nejakú hodnotu. |
| nahradiť (kľúč K, V stará hodnota, V nová hodnota) | Nahradí záznam pre zadaný kľúč len vtedy, ak je aktuálne namapovaný na zadanú hodnotu. |
| nahradiť všetko (funkcia BiFunction) | Nahradí hodnotu každej položky výsledkom vyvolania danej funkcie na tejto položke, kým nebudú spracované všetky položky alebo funkcia nevyvolá výnimku. |
Výhody Java HashMap
- Rýchle načítanie: HashMaps poskytujú neustály časový prístup k prvkom, čo znamená, že vyhľadávanie a vkladanie prvkov je veľmi rýchle.
- Efektívne skladovanie : HashMaps používajú hašovaciu funkciu na mapovanie kľúčov na indexy v poli. To umožňuje rýchle vyhľadávanie hodnôt na základe kľúčov a efektívne ukladanie údajov.
- Flexibilita : HashMaps umožňujú nulové kľúče a hodnoty a môžu ukladať páry kľúč – hodnota akéhokoľvek typu údajov.
- Jednoduché použitie : HashMaps majú jednoduché rozhranie a dajú sa ľahko implementovať v jazyku Java.
- Vhodné pre veľké súbory údajov : HashMaps dokáže spracovať veľké súbory údajov bez spomalenia.
Nevýhody Java HashMap
- Neusporiadané : HashMapy nie sú usporiadané, čo znamená, že poradie, v ktorom sú prvky pridávané do mapy, nie je zachované.
- Nie je bezpečný pre vlákna : HashMaps nie sú bezpečné pre vlákna, čo znamená, že ak k rovnakej hashmape pristupuje viacero vlákien súčasne, môže to viesť k nekonzistentnosti údajov.
- Výkon sa môže zhoršiť : V niektorých prípadoch, ak funkcia hash nie je správne implementovaná alebo ak je faktor zaťaženia príliš vysoký, môže sa výkon HashMap znížiť.
- Zložitejšie ako polia alebo zoznamy : HashMaps môže byť zložitejšie na pochopenie a použitie ako jednoduché polia alebo zoznamy, najmä pre začiatočníkov.
- Vyššie využitie pamäte : Keďže HashMaps používajú základné pole, môžu využívať viac pamäte ako iné dátové štruktúry, ako sú polia alebo zoznamy. To môže byť nevýhodou, ak je problémom využitie pamäte.
Tiež si prečítajte
- Hashmap vs Treemap
- Hashmap vs HashTable
- Nedávne články o Java HashMap
Časté otázky o Java HashMap
1. Čo je HashMap v Jave?
HashMap v jazyku Java je trieda z rámca kolekcie, ktorá môže v sebe ukladať páry kľúč-hodnota.
2. Prečo používať HashMap v Jave?
HashMap v jazyku Java sa používa na ukladanie párov kľúč-hodnota, kde je každý kľúč jedinečný.
3. Aká je výhoda HashMapu?
HashMap sa používa, pretože poskytuje funkcie ako:
- Rýchle načítanie
- Efektívne skladovanie
- Flexibilné použitie
- Jednoduché použitie
- Vhodné pre veľké súbory údajov