I Java, HashMap er en del av Javas samling siden Java 1.2. Denne klassen finnes i java.util pakke. Den gir den grunnleggende implementeringen av kartgrensesnittet til Java. HashMap i Java lagrer dataene i (nøkkel, verdi) par, og du kan få tilgang til dem med en indeks av en annen type (f.eks. et heltall). Ett objekt brukes som nøkkel (indeks) til et annet objekt (verdi). Hvis du prøver å sette inn duplikatnøkkelen i HashMap, vil den erstatte elementet til den tilsvarende nøkkelen.
Hva er HashMap?
Java HashMap den er lik HashTable , men den er usynkronisert. Det tillater å lagre null-nøklene også, men det skal bare være ett null-nøkkelobjekt og det kan være et hvilket som helst antall null-verdier. Denne klassen gir ingen garantier for rekkefølgen på kartet. For å bruke denne klassen og dens metoder, må du importere java.util.HashMap pakken eller dens superklasse.
Innholdsfortegnelse
- Hva er HashMap?
- Java HashMap eksempler
- HashMap-erklæring
- Hierarki av Java HashMap
- Opprette HashMap i Java
- Java HashMap-konstruktører
- Utføre forskjellige operasjoner på HashMap
- Kompleksiteten til HashMap i Java
- Intern struktur av HashMap
- Fordeler og ulemper med Java HashMap
Java HashMap eksempler
Nedenfor er implementeringen av et eksempel på 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);> >}> >}> }> |
>
>Produksjon
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap Erklæring
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parametere:
Det tar to parametere, nemlig som følger:
- Typen nøkler som vedlikeholdes av dette kartet
- Typen kartlagte verdier
Merk: K eys og verdi kan ikke være primitiv datatype. Nøkkelen i Hashmap er gyldig hvis den implementeres hashCode() og equals() metoden , bør den også være uforanderlig (uforanderlig tilpasset objekt ) slik at hashkode og likhet forblir konstant. Verdien i hashmap kan være en hvilken som helst wrapper-klasse, egendefinerte objekter, arrays, hvilken som helst referansetype eller til og med null .
For eksempel : Hashmap kan ha array som verdi, men ikke som nøkkel.
HashMap i Java implementerer Serialiserbar , Klonbar , Kart grensesnitt.Java HashMap utvides Abstrakt kart klasse. De direkte underklassene er LinkedHashMap og PrinterStateReasons .
Hierarki av Java HashMap

Kjennetegn på Java HashMap
Et HashMap er en datastruktur som brukes til å lagre og hente verdier basert på nøkler. Noen av nøkkelegenskapene til et hashmap inkluderer:
- Rask tilgangstid : HashMaps gir konstant tidstilgang til elementer, noe som betyr at henting og innsetting av elementer er veldig rask, vanligvis O(1) tidskompleksitet.
- Bruker hashing-funksjon : HashMaps bruker en hash-funksjon for å tilordne nøkler til indekser i en matrise. Dette gir mulighet for et raskt oppslag av verdier basert på nøkler.
- Lagrer nøkkelverdi-par: Hvert element i et HashMap består av et nøkkelverdi-par. Nøkkelen brukes til å slå opp den tilhørende verdien.
- Støtter nullnøkler og verdier : HashMaps tillater nullverdier og nøkler. Dette betyr at en nullnøkkel kan brukes til å lagre en verdi, og en nullverdi kan knyttes til en nøkkel.
- Ikke bestilt: HashMaps er ikke bestilt, noe som betyr at rekkefølgen elementer legges til på kartet ikke er bevart. Imidlertid er LinkedHashMap en variant av HashMap som bevarer innsettingsrekkefølgen.
- Tillater duplikater : HashMaps tillater dupliserte verdier, men ikke dupliserte nøkler. Hvis en duplikatnøkkel legges til, overskrives den forrige verdien knyttet til nøkkelen.
- Tråd-utrygt : HashMaps er ikke trådsikre, noe som betyr at hvis flere tråder får tilgang til samme hashmap samtidig, kan det føre til datainkonsekvenser. Hvis trådsikkerhet er nødvendig, kan ConcurrentHashMap brukes.
- Kapasitet og belastningsfaktor : HashMaps har en kapasitet, som er antallet elementer den kan holde, og en belastningsfaktor, som er et mål på hvor fullt hashmapet kan være før det endres størrelse.
Opprette HashMap i Java
La oss forstå hvordan vi kan lage HashMap i Java med et eksempel nevnt nedenfor:
Java
tilfelle av
// 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> >}> }> |
>
>Produksjon
25 false 2>
Java HashMap-konstruktører
HashMap gir 4 konstruktører og tilgangsmodifikatoren for hver er offentlig som er oppført som følger:
- HashMap()
- HashMap(int initialCapacity)
- HashMap(int initialCapacity, float loadFactor)
- HashMap(Kart kart)
Diskuterer nå konstruktørene ovenfor en etter en ved siden av å implementere det samme ved hjelp av rene Java-programmer.
1. HashMap()
Det er standardkonstruktøren som lager en forekomst av HashMap med en startkapasitet på 16 og en lastfaktor på 0,75.
Syntaks:
HashMap hm = new HashMap();>
Eksempel
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);> >}> }> |
>
>Produksjon
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)
Den lager en HashMap-forekomst med en spesifisert initial kapasitet og lastfaktor på 0,75.
Syntaks:
HashMap hm = new HashMap(int initialCapacity);>
Eksempel
Bourne igjen skall
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);> >}> }> |
>
>Produksjon
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)
Den oppretter en HashMap-forekomst med en spesifisert startkapasitet og spesifisert lastfaktor.
Syntaks:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Eksempel
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);> >}> }> |
>
>Produksjon
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap(Kart kart)
Den oppretter en forekomst av HashMap med de samme tilordningene som det angitte kartet.
HashMap hm = new HashMap(Kartkart);
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);> >}> }> |
>
>Produksjon
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Utføre forskjellige operasjoner på HashMap
1. Legge til elementer i HashMap i Java
For å legge til et element på kartet, kan vi bruke sette() metode. Innsettingsrekkefølgen beholdes imidlertid ikke i Hashmap. Internt, for hvert element, genereres en separat hash og elementene indekseres basert på denne hashen for å gjøre den mer effektiv.
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);> >}> }> |
>
>Produksjon
USA hvor mange byer
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Endre elementer i HashMap i Java
Etter å ha lagt til elementene hvis vi ønsker å endre elementet, kan det gjøres ved å legge til elementet igjen med sette() metode. Siden elementene i kartet er indeksert ved hjelp av tastene, kan verdien av nøkkelen endres ved ganske enkelt å sette inn den oppdaterte verdien for nøkkelen vi ønsker å endre.
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);> >}> }> |
>
>Produksjon
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Fjerne element fra Java HashMap
For å fjerne et element fra kartet, kan vi bruke fjerne() metode. Denne metoden tar nøkkelverdien og fjerner tilordningen for en nøkkel fra dette kartet hvis den finnes i kartet.
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);> >}> }> |
>
>Produksjon
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Traversering av Java HashMap
Vi kan bruke Iterator-grensesnittet til å krysse en hvilken som helst struktur i innsamlingsrammen. Siden iteratorer jobber med én type data, bruker vi Entry for å løse de to separate typene til et kompatibelt format. Ved å bruke neste()-metoden skriver vi ut oppføringene til 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());> >}> }> |
>
>Produksjon
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
Kompleksiteten til HashMap i Java
HashMap gir konstant tidskompleksitet for grunnleggende operasjoner, hente og sette hvis hash-funksjonen er riktig skrevet og den sprer elementene riktig blant bøttene. Iterasjon over HashMap avhenger av kapasiteten til HashMap og antall nøkkelverdi-par. I utgangspunktet er det direkte proporsjonalt med kapasiteten + størrelsen. Kapasitet er antall bøtter i HashMap. Så det er ikke en god idé å ha et høyt antall bøtter i HashMap til å begynne med.
linux hvordan gi nytt navn til en katalog
| Metoder | Tidskompleksitet | Plass kompleksitet |
|---|---|---|
| Legge til elementer i HashMap | O(1) | PÅ) |
| Fjerner element fra HashMap | O(1) | PÅ) |
| Trekker ut element fra Java | O(1) | PÅ) |
Viktige funksjoner i HashMap
For å få tilgang til en verdi må man kjenne dens nøkkel. HashMap er kjent som HashMap fordi det bruker en teknikk kalt Hashing. Hashing er en teknikk for å konvertere en stor streng til en liten streng som representerer den samme strengen. En kortere verdi hjelper med indeksering og raskere søk. HashSet bruker også HashMap internt.
Noen få viktige funksjoner i HashMap er:
- HashMap er en del av java.util-pakken.
- HashMap utvider en abstrakt klasse AbstractMap som også gir en ufullstendig implementering av kartgrensesnittet.
- Den implementerer også en Klonbar og Serialiserbar grensesnitt. K og V i definisjonen ovenfor representerer henholdsvis nøkkel og verdi.
- HashMap tillater ikke dupliserte nøkler, men tillater dupliserte verdier. Det betyr at en enkelt nøkkel ikke kan inneholde mer enn 1 verdi, men mer enn 1 nøkkel kan inneholde en enkelt verdi.
- HashMap tillater også en nullnøkkel, men bare én gang og flere nullverdier.
- Denne klassen gir ingen garantier for rekkefølgen på kartet; spesielt, det garanterer ikke at rekkefølgen vil forbli konstant over tid. Den er omtrent lik HashTable, men er usynkronisert.
Intern struktur av HashMap
Internt inneholder HashMap en matrise med Node og en node er representert som en klasse som inneholder 4 felt:
- int hash
- K nøkkel
- V-verdi
- Node neste
Det kan sees at noden inneholder en referanse til sitt eget objekt. Så det er en koblet liste.
HashMap:

Node:

Ytelse til HashMap
Ytelsen til HashMap avhenger av 2 parametere som er navngitt som følger:
- Opprinnelig kapasitet
- Belastningsfaktor
1. Utgangskapasitet – Det er kapasiteten til HashMap på tidspunktet for opprettelsen (det er antallet bøtter en HashMap kan inneholde når HashMap er instansiert). I java er den 2^4=16 i utgangspunktet, noe som betyr at den kan inneholde 16 nøkkelverdi-par.
skjulte apper2. Belastningsfaktor – Det er prosentverdien av kapasiteten som kapasiteten til Hashmap skal økes etter (det er den prosentvise fyllingen av bøtter som Rehashing finner sted etter). I java er det 0.75f som standard, noe som betyr at rehashing finner sted etter å ha fylt 75 % av kapasiteten.
3. Terskel – Det er produktet av belastningsfaktor og startkapasitet. I java er det som standard (16 * 0,75 = 12). Det vil si at Rehashing finner sted etter å ha satt inn 12 nøkkelverdi-par i HashMap.
4. Rehashing – Det er prosessen med å doble kapasiteten til HashMap etter at den når terskelen. I java fortsetter HashMap å rehash (som standard) i følgende sekvens – 2^4, 2^5, 2^6, 2^7, …. så videre.
Hvis den opprinnelige kapasiteten holdes høyere, vil rehasking aldri bli utført. Men ved å holde den høyere øker tidskompleksiteten til iterasjonen. Så det bør velges veldig smart for å øke ytelsen. Det forventede antallet verdier bør tas i betraktning for å angi den opprinnelige kapasiteten. Den mest generelt foretrukne lastfaktorverdien er 0,75 som gir en god del mellom tids- og plasskostnader. Lastfaktorens verdi varierer mellom 0 og 1.
Merk: Fra Java 8 og fremover har Java begynt å bruke Self Balancing BST i stedet for en koblet liste for kjeding. Fordelen med selvbalanserende bst er at vi får det verste tilfellet (når hver nøkkel kartlegges til samme spor) søketiden er O(Log n).
Synkronisert HashMap
Som det sies at HashMap er usynkronisert, det vil si at flere tråder kan få tilgang til det samtidig. Hvis flere tråder får tilgang til denne klassen samtidig og minst én tråd manipulerer den strukturelt, er det nødvendig å gjøre den synkronisert eksternt. Det gjøres ved å synkronisere et objekt som innkapsler kartet. Hvis det ikke finnes noe slikt objekt, kan det pakkes rundt Collections.synchronizedMap() for å gjøre HashMap synkronisert og unngå utilsiktet usynkronisert tilgang. Som i følgende eksempel:
Map m = Collections.synchronizedMap(new HashMap(...));>
Nå er Map m synkronisert. Iteratorer av denne klassen er mislykkede hvis strukturmodifikasjoner gjøres etter opprettelsen av iteratoren, på noen måte bortsett fra gjennom iteratorens fjerningsmetode. Ved feil i en iterator vil den kaste ConcurrentModificationException.
Applikasjoner av HashMap:
HashMap er hovedsakelig implementering av hashing. Det er nyttig når vi trenger effektiv implementering av søke-, inn- og sletteoperasjoner. Vennligst referer til applikasjoner av hashing for detaljer.
Metoder i HashMapassociate
- K – Typen av nøklene i kartet.
- I – Type verdier kartlagt i kartet.
| Metode | Beskrivelse |
|---|---|
| klar() | Fjerner alle tilordningene fra dette kartet. |
| klone() | Returnerer en grunn kopi av denne HashMap-forekomsten: selve nøklene og verdiene er ikke klonet. |
| compute(K-tast, BiFunction ? super V,? utvider V> remappingFunction) | Forsøker å beregne en tilordning for den angitte nøkkelen og dens gjeldende tilordnede verdi (eller null hvis det ikke er noen gjeldende tilordning). |
| computeIfAbsent(K-tast, funksjon super K,? utvider V> mappingFunction) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), forsøker du å beregne verdien ved hjelp av den gitte tilordningsfunksjonen og legger den inn i dette kartet med mindre null. |
| computeIfPresent(K-tast, BiFunction ? super V,? utvider V> remappingFunction) | Hvis verdien for den angitte nøkkelen er tilstede og ikke er null, forsøker du å beregne en ny tilordning gitt nøkkelen og dens gjeldende tilordnede verdi. |
| containsKey(Objektnøkkel) | Returnerer sann hvis dette kartet inneholder en tilordning for den angitte nøkkelen. |
| containsValue(Objektverdi) | Returnerer sann hvis dette kartet tilordner én eller flere nøkler til den angitte verdien. |
| entrySet() | Returnerer en settvisning av tilordningene i dette kartet. |
| get (objektnøkkel) | Returnerer verdien som den angitte nøkkelen er tilordnet til, eller null hvis denne tilordningen ikke inneholder noen tilordning for nøkkelen. |
| er tom() | Returnerer sann hvis dette kartet ikke inneholder noen nøkkelverdi-tilordninger. |
| keySet() | Returnerer en settvisning av nøklene i dette kartet. |
| flette (K-tast, V-verdi, BiFunction ? super V,? utvider V> remappingFunction) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi eller er assosiert med null, tilknytt den til den gitte ikke-nullverdien. |
| put(K-tast, V-verdi) | Knytter den angitte verdien til den angitte nøkkelen i dette kartet. |
| putAll(Kart m) | Kopierer alle tilordningene fra det angitte kartet til dette kartet. |
| fjern (objektnøkkel) | Fjerner tilordningen for den angitte nøkkelen fra dette kartet hvis det finnes. |
| størrelse() | Returnerer antall nøkkelverdi-tilordninger i dette kartet. |
| verdier() | Returnerer en samlingsvisning av verdiene i dette kartet. |
Metoder arvet fra klassen java.util.AbstractMap
| METODE | BESKRIVELSE |
|---|---|
| er lik() | Sammenligner det angitte objektet med dette kartet for likhet. |
| hashkode() | Returnerer hash-kodeverdien for dette kartet. |
| toString() | Returnerer en strengrepresentasjon av dette kartet. |
Metoder som er arvet fra grensesnittet java.util.Map
| METODE | BESKRIVELSE |
|---|---|
| er lik() | Sammenligner det angitte objektet med dette kartet for likhet. |
| forEach(BiConsumer action) | Utfører den gitte handlingen for hver oppføring i dette kartet til alle oppføringer er behandlet eller handlingen gir et unntak. |
| getOrDefault(Objektnøkkel, V defaultValue) | Returnerer verdien som den angitte nøkkelen er tilordnet til, eller standardverdi hvis dette kartet ikke inneholder noen tilordning for nøkkelen. |
| hashkode() | Returnerer hash-kodeverdien for dette kartet. |
| putIfAbsent(K-nøkkel, V-verdi) | Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), knytter den til den gitte verdien og returnerer null, ellers returnerer den gjeldende verdien. |
| fjern (objektnøkkel, objektverdi) | Fjerner oppføringen for den angitte nøkkelen bare hvis den for øyeblikket er tilordnet den angitte verdien. |
| erstatte (K-tast, V-verdi) | Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet til en verdi. |
| erstatt (K-tast, V oldValue, V newValue) | Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet den angitte verdien. |
| replaceAll(BiFunction-funksjon) | Erstatter hver oppførings verdi med resultatet av å påkalle den gitte funksjonen på den oppføringen til alle oppføringer er behandlet eller funksjonen gir et unntak. |
Fordeler med Java HashMap
- Rask henting: HashMaps gir konstant tidstilgang til elementer, noe som betyr at gjenfinning og innsetting av elementer går veldig raskt.
- Effektiv lagring : HashMaps bruker en hashing-funksjon for å tilordne nøkler til indekser i en matrise. Dette gir mulighet for raskt oppslag av verdier basert på nøkler, og effektiv lagring av data.
- Fleksibilitet : HashMaps tillater null-nøkler og verdier, og kan lagre nøkkel-verdi-par av enhver datatype.
- Lett å bruke : HashMaps har et enkelt grensesnitt og kan enkelt implementeres i Java.
- Egnet for store datasett : HashMaps kan håndtere store datasett uten å bremse.
Ulemper med Java HashMap
- Uordnet : HashMaps er ikke bestilt, noe som betyr at rekkefølgen elementer legges til på kartet ikke er bevart.
- Ikke trådsikker : HashMaps er ikke trådsikre, noe som betyr at hvis flere tråder får tilgang til samme hashmap samtidig, kan det føre til datainkonsekvenser.
- Ytelsen kan forringes : I noen tilfeller, hvis hashing-funksjonen ikke er riktig implementert eller hvis belastningsfaktoren er for høy, kan ytelsen til en HashMap forringes.
- Mer komplekse enn matriser eller lister : HashMaps kan være mer komplekse å forstå og bruke enn enkle matriser eller lister, spesielt for nybegynnere.
- Høyere minnebruk : Siden HashMaps bruker en underliggende matrise, kan de bruke mer minne enn andre datastrukturer som matriser eller lister. Dette kan være en ulempe hvis minnebruk er en bekymring.
Les også
- Hashmap vs Treemap
- Hashmap vs HashTable
- Nylige artikler om Java HashMap
Vanlige spørsmål om Java HashMap
1. Hva er et HashMap i Java?
HashMap i Java er klassen fra samlingsrammeverket som kan lagre nøkkelverdi-par inne i den.
2. Hvorfor bruke HashMap i Java?
HashMap i Java brukes til å lagre nøkkel-verdi-par der hver nøkkel er unik.
3. Hva er fordelen med HashMap?
HashMap brukes fordi det gir funksjoner som:
- Rask henting
- Effektiv lagring
- Fleksibel å bruke
- Lett å bruke
- Egnet for store datasett