Java valodā HashMap ir daļa no Java kolekcijas kopš Java 1.2. Šī klase ir atrodama java.util iepakojums. Tas nodrošina Java kartes saskarnes pamata ieviešanu. Java HashMap saglabā datus (atslēga, vērtība) pāros, un jūs varat tiem piekļūt, izmantojot cita veida indeksu (piemēram, veselu skaitli). Viens objekts tiek izmantots kā cita objekta (vērtības) atslēga (indekss). Ja mēģināsit ievietot atslēgas dublikātu programmā HashMap, tas aizstās atbilstošās atslēgas elementu.
Kas ir HashMap?
Java HashMap ir līdzīgs HashTable , bet tas nav sinhronizēts. Tas ļauj saglabāt arī nulles atslēgas, taču jābūt tikai vienam nulles atslēgas objektam un var būt jebkurš nulles vērtību skaits. Šī klase negarantē kartes secību. Lai izmantotu šo klasi un tās metodes, jums ir jāimportē java.util.HashMap paka vai tās superklase.
Satura rādītājs
- Kas ir HashMap?
- Java HashMap piemēri
- HashMap deklarācija
- Java HashMap hierarhija
- HashMap izveide Java
- Java HashMap konstruktori
- Dažādu operāciju veikšana vietnē HashMap
- HashMap sarežģītība Java
- HashMap iekšējā struktūra
- Java HashMap priekšrocības un trūkumi
Java HashMap piemēri
Tālāk ir sniegts Java HashMap piemērs:
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);> > }> > }> }> |
>
>Izvade
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10>
HashMap Deklarācija
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametri:
Tam nepieciešami divi parametri, proti, šādi:
- Šajā kartē uzturēto atslēgu veids
- Kartēto vērtību veids
Piezīme: K eys un value nevar būt primitīvs datu tips. Hashmap atslēga ir derīga, ja tā tiek ieviesta hashCode() un equals() metodi , tam jābūt arī nemainīgam (nemainīgam pielāgotam objektam ), lai hashcode un vienlīdzība paliktu nemainīga. Hashmap vērtība var būt jebkura iesaiņojuma klase, pielāgoti objekti, masīvi, jebkurš atsauces veids vai pat null .
Piemēram : Hashmap var būt masīvs kā vērtība, bet ne kā atslēga.
HashMap Java iekārtās Serializējams , Klonējams , Karte saskarnes.Java HashMap paplašina AbstractMap klasē. Tiešās apakšklases ir LinkedHashMap un PrinterStateReasons .
Java HashMap hierarhija
Java HashMap īpašības
HashMap ir datu struktūra, ko izmanto, lai saglabātu un izgūtu vērtības, pamatojoties uz atslēgām. Dažas no galvenajām hashmapa īpašībām ir:
- Ātrs piekļuves laiks : HashMaps nodrošina pastāvīgu laika piekļuvi elementiem, kas nozīmē, ka elementu izguve un ievietošana ir ļoti ātra, parasti O(1) laika sarežģītība.
- Izmanto jaukšanas funkciju : HashMaps izmanto jaucējfunkciju, lai kartētu atslēgas ar indeksiem masīvā. Tas ļauj ātri meklēt vērtības, pamatojoties uz taustiņiem.
- Saglabā atslēgu-vērtību pārus: Katrs HashMap elements sastāv no atslēgas un vērtības pāra. Taustiņš tiek izmantots, lai meklētu saistīto vērtību.
- Atbalsta nulles atslēgas un vērtības : HashMaps ļauj izmantot nulles vērtības un atslēgas. Tas nozīmē, ka nulles atslēgu var izmantot, lai saglabātu vērtību, un nulles vērtību var saistīt ar atslēgu.
- Nav pasūtīts: HashMaps nav sakārtotas, kas nozīmē, ka secība, kādā elementi tiek pievienoti kartei, netiek saglabāti. Tomēr LinkedHashMap ir HashMap variants, kas saglabā ievietošanas secību.
- Atļauj dublikātus : HashMaps ļauj dublēt vērtības, bet ne dublēt atslēgas. Ja tiek pievienota atslēgas dublikāts, ar atslēgu saistītā iepriekšējā vērtība tiek pārrakstīta.
- Pavediens nedrošs : HashMaps nav drošas pavedieniem, kas nozīmē, ka, ja vairāki pavedieni vienlaikus piekļūst vienam un tam pašam hashmap, tas var izraisīt datu nekonsekvenci. Ja nepieciešama pavedienu drošība, var izmantot ConcurrentHashMap.
- Ietilpība un slodzes koeficients : HashMaps ir ietilpība, kas ir elementu skaits, ko tajā var ievietot, un slodzes koeficients, kas norāda, cik pilna var būt hashmap, pirms tā tiek mainīta.
HashMap izveide Java
Ļaujiet mums saprast, kā mēs varam izveidot HashMap Java, izmantojot tālāk minēto piemēru:
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> > }> }> |
>
>Izvade
25 false 2>
Java HashMap konstruktori
HashMap nodrošina 4 konstruktorus, un katra piekļuves modifikators ir publisks, kas ir norādīti šādi:
- HashMap()
- HashMap (sākotnējā ietilpība)
- HashMap (sākotnējā ietilpība, peldošā slodzes koeficients)
- HashMap (kartes karte)
Tagad apspriežam iepriekš minētos konstruktorus pa vienam un to pašu ieviešanu ar tīru Java programmu palīdzību.
1. HashMap()
Tas ir noklusējuma konstruktors, kas izveido HashMap gadījumu ar sākotnējo ietilpību 16 un slodzes koeficientu 0,75.
Sintakse:
HashMap hm = new HashMap();>
Piemērs
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);> > }> }> |
>
>
konvertēšana no virknes uz int javaIzvade
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>
2. HashMap (sākotnējā ietilpība)
Tas izveido HashMap gadījumu ar a norādītā sākotnējā jauda un slodzes koeficients 0,75.
Sintakse:
HashMap hm = new HashMap(int initialCapacity);>
Piemērs
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);> > }> }> |
>
>Izvade
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>
3. HashMap (sākotnējā ietilpība, peldošā slodzes koeficients)
Tas izveido HashMap gadījumu ar noteiktu sākotnējo jaudu un norādīto slodzes koeficientu.
Sintakse:
k tuvākā kaimiņa algoritms
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Piemērs
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);> > }> }> |
>
>Izvade
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>
4. HashMap (kartes karte)
Tas izveido HashMap gadījumu ar tādiem pašiem kartējumiem kā norādītajai kartei.
HashMap hm = new HashMap(Kartes karte);
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);> > }> }> |
>
>Izvade
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}>
Dažādu operāciju veikšana vietnē HashMap
1. Elementu pievienošana HashMap programmā Java
Lai kartei pievienotu kādu elementu, mēs varam izmantot likt () metodi. Tomēr ievietošanas secība Hashmapā netiek saglabāta. Iekšēji katram elementam tiek ģenerēts atsevišķs jaukums un elementi tiek indeksēti, pamatojoties uz šo jaucējkodu, lai padarītu to efektīvāku.
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);> > }> }> |
>
>Izvade
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}>
2. Elementu maiņa Java programmā HashMap
Pēc elementu pievienošanas, ja vēlamies elementu mainīt, to var izdarīt, vēlreiz pievienojot elementu ar likt () metodi. Tā kā kartes elementi tiek indeksēti, izmantojot taustiņus, atslēgas vērtību var mainīt, vienkārši ievietojot atjaunināto vērtību atslēgai, kurai mēs vēlamies mainīt.
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);> > }> }> |
>
>Izvade
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}>
3. Elementa noņemšana no Java HashMap
Lai noņemtu elementu no kartes, mēs varam izmantot noņemt () metodi. Šī metode ņem atslēgas vērtību un no šīs kartes noņem atslēgas kartējumu, ja tā ir kartē.
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);> > }> }> |
>
>Izvade
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 šķērsošana
Mēs varam izmantot Iterator saskarni, lai pārvietotos pa jebkuru kolekcijas ietvara struktūru. Tā kā iteratori strādā ar viena veida datiem, mēs izmantojam ierakstu, lai abus atsevišķos veidus sakārtotu saderīgā formātā. Pēc tam, izmantojot next() metodi, mēs izdrukājam HashMap ierakstus.
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());> > }> }> |
>
>Izvade
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
HashMap sarežģītība Java
HashMap nodrošina pastāvīgu laika sarežģītību pamata operācijām, iegūstiet un ielieciet, ja jaucējfunkcija ir pareizi uzrakstīta un pareizi izkliedē elementus starp spaiņiem. Iterācija, izmantojot HashMap, ir atkarīga no HashMap jaudas un atslēgu-vērtību pāru skaita. Būtībā tas ir tieši proporcionāls jaudai + izmēram. Ietilpība ir segmentu skaits programmā HashMap. Tāpēc sākotnēji HashMap nav ieteicams saglabāt lielu skaitu spaiņu.
Metodes | Laika sarežģītība | Kosmosa sarežģītība |
---|---|---|
Elementu pievienošana programmā HashMap | O(1) | O(N) |
Elementa noņemšana no HashMap | O(1) | O(N) |
Elementa izvilkšana no Java | O(1) | O(N) |
Svarīgas HashMap funkcijas
Lai piekļūtu vērtībai, ir jāzina tās atslēga. HashMap ir pazīstama kā HashMap, jo tā izmanto paņēmienu, ko sauc par jaukšanu. Jaukšana ir paņēmiens lielas virknes pārvēršanai mazā virknē, kas apzīmē to pašu virkni. Īsāka vērtība palīdz indeksēt un ātrāk meklēt. HashSet iekšēji izmanto arī HashMap.
Dažas svarīgas HashMap funkcijas ir:
- HashMap ir daļa no java.util pakotnes.
- HashMap paplašina abstrakto klasi AbstractMap, kas arī nodrošina nepilnīgu kartes saskarnes ieviešanu.
- Tas arī īsteno a Klonējams un Serializējams saskarnes. Iepriekš minētajā definīcijā K un V apzīmē attiecīgi atslēgu un vērtību.
- HashMap neatļauj dublēt atslēgas, bet pieļauj vērtību dublikātus. Tas nozīmē, ka vienā atslēgā nedrīkst būt vairāk par 1 vērtību, bet vairāk nekā 1 atslēgā var būt viena vērtība.
- HashMap pieļauj arī nulles atslēgu, bet tikai vienu un vairākas nulles vērtības.
- Šī klase negarantē kartes secību; jo īpaši tas negarantē, ka pasūtījums laika gaitā paliks nemainīgs. Tas ir aptuveni līdzīgs HashTable, bet nav sinhronizēts.
HashMap iekšējā struktūra
Iekšēji HashMap satur mezglu masīvu, un mezgls tiek attēlots kā klase, kurā ir 4 lauki:
- int hash
- K taustiņš
- V vērtība
- Mezgls nākamais
Var redzēt, ka mezgls satur atsauci uz savu objektu. Tātad tas ir saistīts saraksts.
HashMap:
Mezgls:
HashMap veiktspēja
HashMap veiktspēja ir atkarīga no 2 parametriem, kas tiek nosaukti šādi:
- Sākotnējā jauda
- Slodzes koeficients
1. Sākotnējā jauda – Tā ir HashMap jauda tās izveides laikā (Tas ir segmentu skaits, ko HashMap var saturēt, kad HashMap tiek iemiesots). Java sākotnēji tas ir 2^4=16, kas nozīmē, ka tajā var būt 16 atslēgu vērtību pāri.
2. Slodzes koeficients – Tā ir ietilpības procentuālā vērtība, pēc kuras jāpalielina Hashmap jauda (Tā ir kausu procentuālā aizpildīšana, pēc kuras notiek atkārtota atjaunošana). Java versijā pēc noklusējuma tas ir 0,75 f, kas nozīmē, ka atkārtota jaukšana notiek pēc 75% ietilpības aizpildīšanas.
3. Slieksnis – Tas ir slodzes koeficienta un sākotnējās jaudas produkts. Java pēc noklusējuma tas ir (16 * 0,75 = 12). Tas nozīmē, ka atkārtota jaukšana notiek pēc 12 atslēgu-vērtību pāru ievietošanas HashMap.
4. Rehashing – Tas ir HashMap jaudas dubultošanas process pēc tam, kad tas sasniedz slieksni. Java versijā HashMap turpina atkārtotu jaukšanu (pēc noklusējuma) šādā secībā - 2^4, 2^5, 2^6, 2^7, …. tā tālāk.
Ja sākotnējā jauda tiek saglabāta augstāka, atkārtota jaukšana nekad netiks veikta. Bet, saglabājot to augstāk, tiek palielināta iterācijas laika sarežģītība. Tāpēc tas ir jāizvēlas ļoti gudri, lai palielinātu veiktspēju. Lai iestatītu sākotnējo jaudu, jāņem vērā paredzamais vērtību skaits. Visbiežāk vēlamā slodzes faktora vērtība ir 0,75, kas nodrošina labu darījumu starp laika un telpas izmaksām. Slodzes koeficienta vērtība svārstās no 0 līdz 1.
Piezīme: Sākot ar Java 8, Java ir sākusi izmantot Self Balancing BST, nevis saistīto sarakstu ķēdēšanai. Pašbalansējošās bst priekšrocība ir tāda, ka mēs iegūstam sliktākajā gadījumā (kad katra atslēga tiek kartēta uz vienu un to pašu slotu) meklēšanas laiks ir O(Log n).
Sinhronizēta HashMap
Kā tiek teikts, HashMap nav sinhronizēts, t.i., tai vienlaikus var piekļūt vairāki pavedieni. Ja šai klasei vienlaikus piekļūst vairāki pavedieni un vismaz viens pavediens ar to strukturāli manipulē, tas ir jāpadara ārēji sinhronizēts. Tas tiek darīts, sinhronizējot kādu objektu, kas iekapsulē karti. Ja šāda objekta nav, to var ietīt ap Collections.synchronizedMap(), lai HashMap sinhronizētu un izvairītos no nejaušas nesinhronizētas piekļuves. Kā šajā piemērā:
Map m = Collections.synchronizedMap(new HashMap(...));>
Tagad karte m ir sinhronizēta. Šīs klases iteratori darbojas ātri, ja pēc iteratora izveides tiek veiktas struktūras izmaiņas, izņemot iteratora noņemšanas metodi. Iteratora kļūmes gadījumā tas izliks ConcurrentModificationException.
HashMap lietojumprogrammas:
HashMap galvenokārt ir jaukšanas ieviešana. Tas ir noderīgi, ja mums ir nepieciešama efektīva meklēšanas, ievietošanas un dzēšanas darbību ieviešana. Lūdzu, skatiet jaukšanas lietojumprogrammas sīkākai informācijai.
Metodes programmā HashMapassociate
- K – taustiņu veids kartē.
- IN – kartē kartēto vērtību veids.
Metode | Apraksts |
---|---|
skaidrs () | No šīs kartes tiek noņemti visi kartējumi. |
klons () | Atgriež šīs HashMap instances seklu kopiju: pašas atslēgas un vērtības netiek klonētas. |
aprēķina (K taustiņš, BiFunction ? super V,? paplašina V> remappingFunction) | Mēģina aprēķināt kartējumu norādītajai atslēgai un tās pašreizējai kartētajai vērtībai (vai nullei, ja pašreizējā kartējuma nav). |
computeIfAbsent(K taustiņš, funkcija super K,? paplašina V> kartēšanas funkciju) | Ja norādītā atslēga vēl nav saistīta ar vērtību (vai ir kartēta uz nulli), mēģina aprēķināt tās vērtību, izmantojot doto kartēšanas funkciju, un ievada to šajā kartē, ja vien tā nav nulles vērtība. |
computeIfPresent(K taustiņš, BiFunction ? super V,? paplašina V> remappingFunction) | Ja norādītās atslēgas vērtība ir un nav nulle, mēģina aprēķināt jaunu kartējumu, ņemot vērā atslēgu un tās pašreizējo kartēto vērtību. |
includeKey (objekta atslēga) | Atgriež vērtību True, ja šajā kartē ir norādītās atslēgas kartējums. |
saturVērtība (objekta vērtība) | Atgriež vērtību True, ja šī karte kartē vienu vai vairākas atslēgas uz norādīto vērtību. |
ierakstsSet() | Atgriež šajā kartē ietverto kartējumu kopas skatu. |
iegūt (objekta atslēga) | Atgriež vērtību, kurai norādītā atslēga ir kartēta, vai nulli, ja šajā kartē nav atslēgas kartējuma. |
ir tukšs() | Atgriež vērtību True, ja šajā kartē nav atslēgu vērtību kartējumu. |
keySet() | Atgriež šajā kartē ietverto taustiņu kopas skatu. |
sapludināt (K taustiņš, V vērtība, BiFunction ? super V,? paplašina V> remappingFunction) | Ja norādītā atslēga vēl nav saistīta ar vērtību vai ir saistīta ar nulli, saistiet to ar norādīto vērtību, kas nav nulle. |
likt (taustiņš K, V vērtība) | Saista norādīto vērtību ar norādīto atslēgu šajā kartē. |
ievietot visu (karte m) | Kopē visus kartējumus no norādītās kartes uz šo karti. |
noņemt (objekta atslēga) | Noņem norādītās atslēgas kartējumu no šīs kartes, ja tāda ir. |
Izmērs() | Atgriež atslēgu vērtību kartējumu skaitu šajā kartē. |
vērtības () | Atgriež šajā kartē ietverto vērtību kolekcijas skatu. |
Metodes, kas mantotas no klases java.util.AbstractMap
METODE | APRAKSTS |
---|---|
vienāds () | Vienlīdzības labad salīdzina norādīto objektu ar šo karti. |
hashCode() | Atgriež šīs kartes jaucējkoda vērtību. |
toString() | Atgriež šīs kartes virknes attēlojumu. |
Metodes, kas mantotas no interfeisa java.util.Map
METODE Ridhima Tiwari | APRAKSTS |
---|---|
vienāds () | Vienlīdzības labad salīdzina norādīto objektu ar šo karti. |
forEach (divu patērētāju darbība) | Veic norādīto darbību katram ierakstam šajā kartē, līdz visi ieraksti ir apstrādāti vai darbība rada izņēmumu. |
getOrDefault (objekta atslēga, V noklusējuma vērtība) | Atgriež vērtību, ar kuru norādītā atslēga ir kartēta, vai noklusējuma vērtību, ja šajā kartē nav atslēgas kartējuma. |
hashCode() | Atgriež šīs kartes jaucējkoda vērtību. |
putJaNav(atslēga K, V vērtība) | Ja norādītā atslēga vēl nav saistīta ar vērtību (vai ir kartēta uz nulli), saista to ar doto vērtību un atgriež nulli, pretējā gadījumā atgriež pašreizējo vērtību. |
noņemt (objekta atslēga, objekta vērtība) | Noņem norādītās atslēgas ierakstu tikai tad, ja tas pašlaik ir kartēts ar norādīto vērtību. |
aizstāt (taustiņš K, V vērtība) | Aizstāj norādītās atslēgas ierakstu tikai tad, ja tā pašlaik ir saistīta ar kādu vērtību. |
aizstāt (atslēga K, V oldValue, V newValue) | Aizstāj norādītās atslēgas ierakstu tikai tad, ja pašlaik tas ir kartēts ar norādīto vērtību. |
aizstāt visu (BiFunction funkcija) | Aizstāj katra ieraksta vērtību ar attiecīgā ieraksta norādītās funkcijas izsaukšanas rezultātu, līdz visi ieraksti ir apstrādāti vai funkcija rada izņēmumu. |
Java HashMap priekšrocības
- Ātra izgūšana: HashMaps nodrošina pastāvīgu piekļuvi elementiem laikā, kas nozīmē, ka elementu izgūšana un ievietošana notiek ļoti ātri.
- Efektīva uzglabāšana : HashMaps izmanto jaukšanas funkciju, lai kartētu atslēgas ar indeksiem masīvā. Tas ļauj ātri meklēt vērtības, pamatojoties uz atslēgām, un efektīvi uzglabāt datus.
- Elastīgums : HashMaps ļauj izmantot nulles atslēgas un vērtības, kā arī var saglabāt jebkura veida datu atslēgu un vērtību pārus.
- Viegli izmantot : HashMaps ir vienkāršs interfeiss, un to var viegli ieviest Java.
- Piemērots lielām datu kopām : HashMaps var apstrādāt lielas datu kopas, nepalēninot ātrumu.
Java HashMap trūkumi
- Nesakārtots : HashMaps nav sakārtotas, kas nozīmē, ka secība, kādā elementi tiek pievienoti kartei, netiek saglabāta.
- Nav drošs pavedienam : HashMaps nav drošas pavedieniem, kas nozīmē, ka, ja vairāki pavedieni vienlaikus piekļūst vienam un tam pašam hashmap, tas var izraisīt datu nekonsekvenci.
- Veiktspēja var pasliktināties : Dažos gadījumos, ja jaukšanas funkcija nav pareizi ieviesta vai ja slodzes koeficients ir pārāk augsts, HashMap veiktspēja var pasliktināties.
- Sarežģītāk nekā masīvi vai saraksti : HashMaps var būt sarežģītāk saprotamas un lietojamas nekā vienkāršus masīvus vai sarakstus, īpaši iesācējiem.
- Lielāks atmiņas lietojums : Tā kā HashMaps izmanto pamatā esošo masīvu, tās var izmantot vairāk atmiņas nekā citas datu struktūras, piemēram, masīvi vai saraksti. Tas var būt trūkums, ja bažas rada atmiņas lietojums.
Arī Lasīt
- Hashmap vs Treemap
- Hashmap vs HashTable
- Jaunākie raksti par Java HashMap
Bieži uzdotie jautājumi par Java HashMap
1. Kas ir HashMap Java?
Java HashMap ir klase no kolekcijas ietvara, kas tajā var glabāt atslēgu un vērtību pārus.
2. Kāpēc izmantot HashMap Java?
Java HashMap tiek izmantots atslēgu un vērtību pāru glabāšanai, kur katra atslēga ir unikāla.
3. Kāds ir HashMap ieguvums?
HashMap tiek izmantots, jo tas nodrošina tādas funkcijas kā:
- Ātra izgūšana
- Efektīva uzglabāšana
- Elastīgi lietojams
- Viegli izmantot
- Piemērots lielām datu kopām