Java, HashMap yra „Java“ kolekcijos dalis nuo „Java 1.2“. Ši klasė randama java.util paketą. Tai suteikia pagrindinį „Java“ žemėlapio sąsajos įgyvendinimą. „HashMap“ programoje „Java“ saugo duomenis poromis (raktas, reikšmė) ir galite juos pasiekti naudodami kito tipo indeksą (pvz., sveikąjį skaičių). Vienas objektas naudojamas kaip kito objekto (reikšmės) raktas (indeksas). Jei bandysite įterpti pasikartojantį raktą į HashMap, jis pakeis atitinkamo rakto elementą.
Kas yra HashMap?
Java HashMap yra panašus į HashTable , bet jis nesinchronizuotas. Tai leidžia saugoti ir nulinius raktus, tačiau turi būti tik vienas nulinio rakto objektas ir gali būti bet koks nulinių reikšmių skaičius. Ši klasė nesuteikia garantijų dėl žemėlapio eiliškumo. Norėdami naudoti šią klasę ir jos metodus, turite importuoti java.util.HashMap paketą arba jo superklasę.
Turinys
- Kas yra HashMap?
- Java HashMap pavyzdžiai
- HashMap deklaracija
- „Java HashMap“ hierarchija
- „HashMap“ kūrimas „Java“.
- Java HashMap konstruktoriai
- Įvairių operacijų atlikimas su HashMap
- HashMap sudėtingumas Java
- „HashMap“ vidinė struktūra
- Java HashMap privalumai ir trūkumai
Java HashMap pavyzdžiai
Žemiau pateikiamas „Java HashMap“ pavyzdžio įgyvendinimas:
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);> >}> >}> }> |
>
įterpimo rūšiavimo algoritmas
>Išvestis
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap Deklaracija
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametrai:
Tam reikalingi du parametrai, būtent taip:
- Šiame žemėlapyje palaikomų raktų tipas
- Susietų verčių tipas
Pastaba: K eys ir value negali būti primityvūs duomenų tipai. Hashmap raktas galioja, jei jis įgyvendinamas hashCode() ir equals() metodus , jis taip pat turėtų būti nekintamas (nekeičiamas pasirinktinis objektas ), kad maišos kodas ir lygybė išliktų pastovūs. Hashmap reikšmė gali būti bet kokia įpakavimo klasė, pasirinktiniai objektai, masyvai, bet koks nuorodos tipas arba net nulis .
Pavyzdžiui : Hashmap gali turėti masyvą kaip vertę, bet ne kaip raktą.
HashMap Java priemonėse Serializuojama , Galima klonuoti , Žemėlapis sąsajos.Java HashMap plečiasi AbstractMap klasė. Tiesioginiai poklasiai yra LinkedHashMap ir PrinterStateReasons .
„Java HashMap“ hierarchija
Java HashMap charakteristikos
„HashMap“ yra duomenų struktūra, naudojama raktais pagrįstoms reikšmėms saugoti ir gauti. Kai kurios pagrindinės maišos žemėlapio savybės:
- Greitas prieigos laikas : HashMaps suteikia nuolatinę laiko prieigą prie elementų, o tai reiškia, kad elementų paieška ir įterpimas yra labai greitas, paprastai O(1) laiko sudėtingumas.
- Naudoja maišos funkciją : HashMaps naudoja maišos funkciją, kad susietų raktus su masyvo indeksais. Tai leidžia greitai ieškoti verčių pagal raktus.
- Išsaugomos rakto-reikšmių poros: Kiekvienas HashMap elementas susideda iš rakto-reikšmių poros. Raktas naudojamas susietai vertei ieškoti.
- Palaiko nulinius raktus ir reikšmes : HashMaps leidžia naudoti nulines reikšmes ir raktus. Tai reiškia, kad nulinis raktas gali būti naudojamas reikšmei išsaugoti, o nulinė reikšmė gali būti susieta su raktu.
- Neužsakyta: HashMaps nėra tvarkomi, o tai reiškia, kad elementų įtraukimo į žemėlapį tvarka neišsaugoma. Tačiau „LinkedHashMap“ yra „HashMap“ variantas, išsaugantis įterpimo tvarką.
- Leidžia kopijuoti : HashMaps leidžia pasikartojančias vertes, bet ne pasikartojančius raktus. Jei pridedamas pasikartojantis raktas, ankstesnė su raktu susijusi reikšmė perrašoma.
- Siūlas nesaugus : HashMaps nėra saugūs gijai, o tai reiškia, kad jei kelios gijos vienu metu pasiekia tą pačią maišos žemėlapį, gali atsirasti duomenų neatitikimų. Jei reikalinga gijų sauga, galima naudoti ConcurrentHashMap.
- Talpa ir apkrovos koeficientas : HashMaps turi talpą, kuri yra elementų, kuriuos jis gali turėti, skaičių ir apkrovos koeficientą, kuris yra matas, kiek pilnas maišos žemėlapis gali būti prieš keičiant jo dydį.
„HashMap“ kūrimas „Java“.
Leiskite mums suprasti, kaip galime sukurti „HashMap“ „Java“, naudodami toliau pateiktą pavyzdį:
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> >}> }> |
>
>Išvestis
25 false 2>
Java HashMap konstruktoriai
„HashMap“ pateikia 4 konstruktorius ir kiekvieno prieigos modifikatorius yra viešas, kurie išvardyti taip:
- HashMap ()
- HashMap (tarp pradinė talpa)
- HashMap (tarp pradinė talpa, float loadFactor)
- HashMap (žemėlapio žemėlapis)
Dabar aptariame aukščiau nurodytus konstruktorius po vieną, o tuo pačiu įgyvendiname švariomis Java programomis.
1. HashMap ()
Tai numatytasis konstruktorius, sukuriantis HashMap egzempliorių, kurio pradinė talpa yra 16 ir apkrovos koeficientas 0,75.
Sintaksė:
HashMap hm = new HashMap();>
Pavyzdys
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);> >}> }> |
>
>Išvestis
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 2. HashMap (tarp pradinė talpa)
Jis sukuria HashMap egzempliorių su a nurodyta pradinė talpa ir apkrovos koeficientas 0,75.
Sintaksė:
HashMap hm = new HashMap(int initialCapacity);>
Pavyzdys
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);> >}> }> |
>
>Išvestis
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 3. HashMap (tarp pradinė talpa, float loadFactor)
Jis sukuria HashMap egzempliorių su nurodyta pradine talpa ir nurodytu apkrovos koeficientu.
Sintaksė:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Pavyzdys
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);> >}> }> |
>
>Išvestis
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (žemėlapio žemėlapis)
Jis sukuria „HashMap“ egzempliorių su tokiais pat atvaizdais kaip ir nurodytas žemėlapis.
HashMap hm = naujas HashMap (žemėlapio žemėlapis);
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);> >}> }> |
>
>Išvestis
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Įvairių operacijų atlikimas su HashMap
1. Elementų pridėjimas „HashMap“ programoje „Java“.
Norėdami pridėti elementą į žemėlapį, galime naudoti įdėti () metodas. Tačiau įterpimo tvarka Hashmapoje neišsaugoma. Viduje kiekvienam elementui sukuriama atskira maiša ir elementai indeksuojami pagal šią maišą, kad ji būtų efektyvesnė.
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);> >}> }> |
>
>Išvestis
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Elementų keitimas „HashMap“ programoje „Java“.
Pridėjus elementus, jei norime pakeisti elementą, tai galima padaryti dar kartą pridedant elementą su įdėti () metodas. Kadangi elementai žemėlapyje indeksuojami naudojant klavišus, rakto reikšmę galima pakeisti tiesiog įterpiant atnaujintą rakto, kurį norime pakeisti, reikš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);> >}> }> |
>
>Išvestis
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Elemento pašalinimas iš Java HashMap
Norėdami pašalinti elementą iš žemėlapio, galime naudoti pašalinti () metodas. Šis metodas paima rakto reikšmę ir pašalina rakto susiejimą iš šio žemėlapio, jei jis yra žemėlapyje.
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);> >}> }> |
>
>Išvestis
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Java HashMap perėjimas
Galime naudoti „Iterator“ sąsają, norėdami pereiti per bet kurią kolekcijos struktūrą. Kadangi Iteratoriai dirba su vieno tipo duomenimis, mes naudojame Entry, kad išskirstytume du skirtingus tipus į suderinamą formatą. Tada naudodami next() metodą spausdiname HashMap įrašus.
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());> >}> }> |
>
>Išvestis
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
HashMap sudėtingumas Java
HashMap suteikia pastovų laiko sudėtingumą pagrindinėms operacijoms, gauti ir įdėti, jei maišos funkcija yra tinkamai parašyta ir tinkamai paskirsto elementus tarp kibirų. Iteracija per HashMap priklauso nuo HashMap talpos ir rakto-reikšmių porų skaičiaus. Iš esmės tai yra tiesiogiai proporcinga talpai + dydžiui. Talpa yra segmentų skaičius „HashMap“. Taigi iš pradžių HashMap laikyti daug kibirų nėra gera idėja.
| Metodai | Laiko sudėtingumas | Erdvės sudėtingumas |
|---|---|---|
| Elementų pridėjimas „HashMap“. | O(1) java eilučių kūrėjas | O(N) |
| Elemento pašalinimas iš HashMap | O(1) | O(N) |
| Elemento ištraukimas iš Java | O(1) | O(N) |
Svarbios „HashMap“ savybės
Norint pasiekti vertę, reikia žinoti jos raktą. HashMap yra žinomas kaip HashMap, nes jame naudojama technika, vadinama maišos apdorojimu. Maiša yra būdas konvertuoti didelę eilutę į mažą eilutę, kuri reiškia tą pačią eilutę. Trumpesnė reikšmė padeda indeksuoti ir greičiau atlikti paiešką. HashSet taip pat viduje naudoja HashMap.
Keletas svarbių „HashMap“ funkcijų yra šios:
- HashMap yra java.util paketo dalis.
- „HashMap“ išplečia abstrakčiąją klasę „AbstractMap“, kuri taip pat suteikia nepilną žemėlapio sąsajos įgyvendinimą.
- Taip pat įgyvendinama a Galima klonuoti ir Serializuojama sąsajos. K ir V aukščiau pateiktame apibrėžime atitinkamai reiškia raktą ir reikšmę.
- HashMap neleidžia pasikartojančių raktų, bet leidžia pasikartojančias vertes. Tai reiškia, kad viename rakte negali būti daugiau nei 1 reikšmė, bet daugiau nei 1 raktas gali turėti vieną reikšmę.
- „HashMap“ taip pat leidžia nulinį raktą, bet tik vieną kartą ir kelias nulines reikšmes.
- Ši klasė nesuteikia garantijų dėl žemėlapio eiliškumo; visų pirma, tai negarantuoja, kad tvarka laikui bėgant išliks nepakitusi. Jis yra maždaug panašus į HashTable, bet yra nesinchronizuotas.
„HashMap“ vidinė struktūra
„HashMap“ viduje yra mazgo masyvas, o mazgas vaizduojamas kaip klasė, kurią sudaro 4 laukai:
- int maišos
- K klavišas
- V vertė
- Kitas mazgas
Galima pastebėti, kad mazge yra nuoroda į savo objektą. Taigi tai yra susietas sąrašas.
HashMap:
Mazgas:
HashMap našumas
„HashMap“ našumas priklauso nuo 2 parametrų, kurie pavadinti taip:
- Pradinė talpa
- Apkrovos koeficientas
1. Pradinė talpa – Tai yra „HashMap“ talpa jo sukūrimo metu (tai segmentų, kuriuos HashMap gali talpinti, kai „HashMap“ yra instantiatyvus, skaičius). Java iš pradžių yra 2^4 = 16, tai reiškia, kad joje gali būti 16 raktų ir reikšmių porų.
2. Apkrovos koeficientas – Tai procentinė talpos reikšmė, po kurios turi būti padidinta Hashmap talpa (tai procentinė talpų užpildymo dalis, po kurios vyksta pakartotinis apdorojimas). Java pagal numatytuosius nustatymus jis yra 0,75 f, o tai reiškia, kad pakartotinė maiša atliekama užpildžius 75 % talpos.
3. Slenkstis – Tai apkrovos koeficiento ir pradinės talpos produktas. Java pagal numatytuosius nustatymus tai yra (16 * 0,75 = 12). Tai reiškia, kad pakartotinis maišymas įvyksta įterpus 12 raktų ir reikšmių porų į HashMap.
4. Perdirbimas – Tai HashMap talpos padvigubinimo procesas, kai jis pasiekia slenkstį. „Java“ versijoje „HashMap“ ir toliau atlieka maišą (pagal numatytuosius nustatymus) tokia seka – 2^4, 2^5, 2^6, 2^7, …. taip toliau.
Jei pradinis pajėgumas išliks didesnis, pakartotinis maišymas niekada nebus atliktas. Tačiau išlaikant jį aukštesnį, pailgėja iteracijos laiko sudėtingumas. Taigi, norint padidinti našumą, jį reikėtų rinktis labai sumaniai. Norint nustatyti pradinį pajėgumą, reikia atsižvelgti į numatomą verčių skaičių. Dažniausiai pageidaujama apkrovos koeficiento vertė yra 0,75, o tai suteikia gerą laiko ir vietos sąnaudų santykį. Apkrovos koeficiento reikšmė svyruoja nuo 0 iki 1.
Pastaba: Nuo „Java 8“ versijos „Java“ pradėjo naudoti savaiminio balansavimo BST, o ne susietą sąrašą grandinės sujungimui. Savaiminio balansavimo bst privalumas yra tas, kad gauname blogiausią atvejį (kai kiekvienas raktas susieja tą patį lizdą) paieškos laikas yra O(Log n).
Sinchronizuotas HashMap
Kaip sakoma, „HashMap“ yra nesinchronizuotas, ty kelios gijos gali prieiti prie jo vienu metu. Jei šią klasę vienu metu pasiekia kelios gijos ir bent viena gija manipuliuoja ja struktūriškai, būtina ją sinchronizuoti išoriškai. Tai atliekama sinchronizuojant tam tikrą objektą, kuris apima žemėlapį. Jei tokio objekto nėra, jį galima apvynioti Collections.synchronizedMap(), kad HashMap būtų sinchronizuotas ir išvengta atsitiktinės nesinchronizuotos prieigos. Kaip šiame pavyzdyje:
Map m = Collections.synchronizedMap(new HashMap(...));>
Dabar žemėlapis m yra sinchronizuotas. Šios klasės iteratoriai yra greiti, jei sukūrus iteratorių atliekami bet kokie struktūros pakeitimai, išskyrus taikant iteratoriaus pašalinimo metodą. Sugedus iteratoriui, jis išmes „ConcurrentModificationException“.
„HashMap“ programos:
HashMap daugiausia yra maišos įgyvendinimas. Tai naudinga, kai reikia efektyviai įgyvendinti paieškos, įterpimo ir trynimo operacijas. Prašome žiūrėti į maišos programos dėl detalių.
HashMapassociate metodai
- K – klavišų tipas žemėlapyje.
- IN – Žemėlapyje susietų verčių tipas.
| Metodas | apibūdinimas |
|---|---|
| aišku () | Iš šio žemėlapio pašalinami visi atvaizdai. |
| klonas () | Grąžina negilią šio HashMap egzemplioriaus kopiją: patys raktai ir reikšmės nėra klonuoti. |
| compute (K klavišas, BiFunction ? super V,? išplečia V> remappingFunction) | Bandoma apskaičiuoti nurodyto rakto ir jo dabartinės susietos vertės susiejimą (arba nulinę, jei dabartinio susiejimo nėra). |
| computeIfAbsent(K klavišas, funkcija super K,? išplečia V> atvaizdavimo funkciją) | Jei nurodytas raktas dar nesusietas su reikšme (arba susietas su nuliu), bando apskaičiuoti jo vertę naudodamas nurodytą susiejimo funkciją ir įveda jį į šį žemėlapį, nebent nulis. |
| computeIfPresent(K klavišas, BiFunction ? super V,? išplečia V> remappingFunction) | Jei nurodyto rakto reikšmė yra ir nėra nulinė, bandoma apskaičiuoti naują susiejimą, atsižvelgiant į raktą ir jo dabartinę susietą reikšmę. |
| includeKey (objekto raktas) | Grąžina true, jei šiame žemėlapyje yra nurodyto rakto atvaizdas. |
| includeValue (objekto vertė) | Grąžina true, jei šis žemėlapis susieja vieną ar daugiau raktų su nurodyta verte. |
| įrašasSet() | Grąžina šiame žemėlapyje esančių atvaizdų rinkinio rodinį. |
| gauti (objekto raktas) | Grąžina reikšmę, su kuria susietas nurodytas raktas, arba nulinę vertę, jei šiame žemėlapyje nėra rakto susiejimo. |
| Yra tuščias() | Grąžina tiesa, jei šiame žemėlapyje nėra raktų ir reikšmių susiejimo. |
| keySet() | Grąžina šiame žemėlapyje esančių raktų rinkinio rodinį. |
| merge(K raktas, V reikšmė, BiFunction ? super V,? išplečia V> remappingFunction) | Jei nurodytas raktas dar nesusietas su reikšme arba yra susietas su nuliu, susiekite jį su nurodyta nenuline verte. |
| įdėti (K klavišas, V reikšmė) | Nurodytą reikšmę susieja su nurodytu raktu šiame žemėlapyje. |
| įdėti viską (žemėlapis m) | Nukopijuoja visus žemėlapius iš nurodyto žemėlapio į šį žemėlapį. |
| pašalinti (objekto raktas) | Pašalina nurodyto rakto atvaizdavimą iš šio žemėlapio, jei yra. |
| dydis () | Grąžina šiame žemėlapyje esančių raktų ir reikšmių susiejimo skaičių. |
| reikšmės () | Grąžina šiame žemėlapyje esančių verčių rinkinio rodinį. |
Metodai, paveldėti iš klasės java.util.AbstractMap
| METODAS | APIBŪDINIMAS |
|---|---|
| lygus () | Lygina nurodytą objektą su šiuo žemėlapiu, kad būtų lygybė. |
| maišos kodas () | Grąžina šio žemėlapio maišos kodo reikšmę. |
| toString() | Pateikia šio žemėlapio eilutę. |
Metodai, paveldėti iš sąsajos java.util.Map
| METODAS | APIBŪDINIMAS |
|---|---|
| lygus () | Lygina nurodytą objektą su šiuo žemėlapiu, kad būtų lygybė. |
| už kiekvieną (dviejų vartotojų veiksmas) | Atlieka nurodytą veiksmą kiekvienam šio žemėlapio įrašui, kol visi įrašai bus apdoroti arba veiksmas padarys išimtį. |
| getOrDefault (objekto raktas, V numatytoji vertė) | Grąžina reikšmę, su kuria susietas nurodytas raktas, arba defaultValue, jei šiame žemėlapyje nėra rakto susiejimo. |
| maišos kodas () | Grąžina šio žemėlapio maišos kodo reikšmę. |
| putIf Absent (K raktas, V reikšmė) | Jei nurodytas raktas dar nesusietas su reikšme (arba susietas su nuliu), susieja jį su nurodyta reikšme ir grąžina nulį, kitu atveju grąžina dabartinę reikšmę. |
| pašalinti (objekto raktas, objekto vertė) | Pašalina nurodyto rakto įrašą tik tuo atveju, jei jis šiuo metu susietas su nurodyta reikšme. |
| pakeisti (K klavišas, V reikšmė) | Pakeičia nurodyto rakto įrašą tik tuo atveju, jei jis šiuo metu susietas su kokia nors verte. |
| pakeisti (K raktas, V senoji vertė, V nauja vertė) | Pakeičia nurodyto rakto įrašą tik tuo atveju, jei šiuo metu susietas su nurodyta reikšme. |
| pakeisti viską (funkcija „BiFunction“) | Pakeičia kiekvieno įrašo reikšmę to įrašo nurodytos funkcijos iškvietimo rezultatu, kol visi įrašai bus apdoroti arba funkcija padarys išimtį. |
„Java HashMap“ pranašumai
- Greitas gavimas: HashMaps suteikia nuolatinę laiko prieigą prie elementų, o tai reiškia, kad elementų paieška ir įterpimas yra labai greitas.
- Efektyvus saugojimas : HashMaps naudoja maišos funkciją, kad susietų raktus su masyvo indeksais. Tai leidžia greitai ieškoti verčių pagal raktus ir efektyviai saugoti duomenis.
- Lankstumas : „HashMaps“ leidžia naudoti nulinius raktus ir reikšmes ir gali saugoti bet kokio tipo duomenų raktų ir verčių poras.
- Paprasta naudoti : HashMaps turi paprastą sąsają ir gali būti lengvai įdiegta Java.
- Tinka dideliems duomenų rinkiniams : HashMaps gali apdoroti didelius duomenų rinkinius nesulėtinant.
Java HashMap trūkumai
- Neužsakyta : HashMaps nėra tvarkomi, o tai reiškia, kad elementų įtraukimo į žemėlapį tvarka neišsaugoma.
- Nesaugus siūlams : HashMaps nėra saugūs gijai, o tai reiškia, kad jei kelios gijos vienu metu pasiekia tą pačią maišos žemėlapį, gali atsirasti duomenų neatitikimų.
- Našumas gali pablogėti : Kai kuriais atvejais, jei maišos funkcija nėra tinkamai įdiegta arba jei apkrovos koeficientas yra per didelis, HashMap našumas gali pablogėti.
- Sudėtingesnis nei masyvai ar sąrašai : HashMaps suprasti ir naudoti gali būti sudėtingiau nei paprastus masyvus ar sąrašus, ypač pradedantiesiems.
- Didesnis atminties naudojimas : Kadangi HashMaps naudoja pagrindinį masyvą, jie gali naudoti daugiau atminties nei kitos duomenų struktūros, pvz., masyvai ar sąrašai. Tai gali būti trūkumas, jei susirūpinimą kelia atminties naudojimas.
Taip pat Skaitykite
- Hashmapas vs Treemap
- Hashmap vs HashTable
- Naujausi straipsniai apie Java HashMap
DUK apie Java HashMap
1. Kas yra „HashMap“ programoje „Java“?
„HashMap“ programoje „Java“ yra klasė iš rinkimo sistemos, kuri gali saugoti raktų ir verčių poras.
2. Kodėl Java naudoti HashMap?
„HashMap“ programoje „Java“ naudojamas raktų ir verčių poroms saugoti, kai kiekvienas raktas yra unikalus.
3. Kuo naudingas HashMap?
„HashMap“ naudojamas, nes jame yra tokių funkcijų kaip:
- Greitas gavimas
- Efektyvus saugojimas
- Lankstus naudoti
- Paprasta naudoti
- Tinka dideliems duomenų rinkiniams