Op Java is HashMap maakt sinds Java 1.2 deel uit van de Java-collectie. Deze klasse is te vinden in java.util pakket. Het biedt de basisimplementatie van de kaartinterface van Java. HashMap in Java slaat de gegevens op in (sleutel, waarde) paren, en u kunt er toegang toe krijgen via een index van een ander type (bijvoorbeeld een geheel getal). Eén object wordt gebruikt als sleutel (index) voor een ander object (waarde). Als u de dubbele sleutel in HashMap probeert in te voegen, zal deze het element van de overeenkomstige sleutel vervangen.

Wat is HashMap?

Java-hashmap is gelijkaardig aan HashTabel , maar het is niet gesynchroniseerd. Hiermee kunnen ook de nulsleutels worden opgeslagen, maar er mag slechts één nulsleutelobject zijn en er kan een willekeurig aantal nulwaarden zijn. Deze klasse geeft geen garanties met betrekking tot de volgorde van de kaart. Om deze klasse en zijn methoden te gebruiken, moet u importeren java.util.HashMap pakket of zijn superklasse.

Inhoudsopgave

• Wat is HashMap?
• Java HashMap-voorbeelden
• HashMap-verklaring
• Hiërarchie van Java HashMap
• HashMap maken in Java
• Java HashMap-constructeurs
• Verschillende bewerkingen uitvoeren op HashMap
• Complexiteit van HashMap in Java
• Interne structuur van HashMap
• Voor- en nadelen van Java HashMap

Java HashMap-voorbeelden

Hieronder ziet u de implementatie van een voorbeeld van Java HashMap:

Java

>

>

Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10>

Hash kaart Verklaring

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>

Parameters:

Er zijn twee parameters nodig, namelijk als volgt:

• Het type sleutels dat door deze kaart wordt onderhouden
• Het type toegewezen waarden

Opmerking: K eys en waarde kunnen geen primitief gegevenstype zijn. De sleutel in Hashmap is geldig als deze wordt geïmplementeerd hashCode() en equals() methode , moet het ook onveranderlijk zijn (onveranderlijk aangepast object ), zodat hashcode en gelijkheid constant blijven. Waarde in hashmap kan elke wrapperklasse, aangepaste objecten, arrays, elk referentietype of zelfs null zijn.

Bijvoorbeeld : Hashmap kan een array als waarde hebben, maar niet als sleutel.

HashMap in Java-implementaties Serialiseerbaar , Kloonbaar , Kaart interfaces.Java HashMap breidt zich uit Samenvattingkaart klas. De directe subklassen zijn GelinkteHashMap En PrinterStateRedenen .

Hiërarchie van Java HashMap

Kenmerken van Java HashMap

Een HashMap is een gegevensstructuur die wordt gebruikt om waarden op basis van sleutels op te slaan en op te halen. Enkele van de belangrijkste kenmerken van een hashmap zijn:

• Snelle toegangstijd : HashMaps bieden constante tijdtoegang tot elementen, wat betekent dat het ophalen en invoegen van elementen erg snel gaat, meestal O(1) tijdscomplexiteit.
• Maakt gebruik van hashfunctie : HashMaps gebruikt een hash-functie om sleutels toe te wijzen aan indices in een array. Hierdoor kunt u snel waarden opzoeken op basis van sleutels.
• Slaat sleutel-waardeparen op: Elk element in een HashMap bestaat uit een sleutelwaardepaar. De sleutel wordt gebruikt om de bijbehorende waarde op te zoeken.
• Ondersteunt null-sleutels en -waarden : HashMaps staan ​​nulwaarden en sleutels toe. Dit betekent dat een nulsleutel kan worden gebruikt om een ​​waarde op te slaan, en dat een nulwaarde aan een sleutel kan worden gekoppeld.
• Niet besteld: HashMaps zijn niet geordend, wat betekent dat de volgorde waarin elementen aan de kaart worden toegevoegd niet behouden blijft. LinkedHashMap is echter een variant van HashMap die de invoegvolgorde behoudt.
• Maakt duplicaten mogelijk : HashMaps staan ​​dubbele waarden toe, maar geen dubbele sleutels. Als er een dubbele sleutel wordt toegevoegd, wordt de vorige waarde die aan de sleutel is gekoppeld, overschreven.
• Thread-onveilig : HashMaps zijn niet thread-safe, wat betekent dat als meerdere threads tegelijkertijd toegang hebben tot dezelfde hashmap, dit kan leiden tot inconsistenties in de gegevens. Als draadveiligheid vereist is, kan ConcurrentHashMap worden gebruikt.
• Capaciteit en beladingsgraad : HashMaps hebben een capaciteit, wat het aantal elementen is dat het kan bevatten, en een belastingsfactor, wat de maat is van hoe vol de hashmap kan zijn voordat deze wordt vergroot of verkleind.

HashMap maken in Java

Laten we begrijpen hoe we HashMap in Java kunnen maken met het onderstaande voorbeeld:

Java

>

>

25 false 2>

Java HashMap-constructeurs

HashMap biedt 4 constructors en de toegangsmodificator van elk is openbaar, die als volgt wordt weergegeven:

1. Hash kaart()
2. HashMap(int initiële capaciteit)
3. HashMap (int initiële capaciteit, float loadFactor)
4. HashMap (kaartkaart)

Bespreek nu de bovenstaande constructors één voor één, naast de implementatie ervan met behulp van schone Java-programma's.

1. HashMap()

Het is de standaardconstructor die een exemplaar van HashMap maakt met een initiële capaciteit van 16 en een belastingsfactor van 0,75.

Syntaxis:

HashMap hm = new HashMap();>

Voorbeeld

Java

>

>

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 initiële capaciteit)

Het creëert een HashMap-instantie met een gespecificeerde initiële capaciteit en bezettingsgraad van 0,75.

Syntaxis:

HashMap hm = new HashMap(int initialCapacity);>

Voorbeeld

Java

>

>

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 initiële capaciteit, float loadFactor)

Het creëert een HashMap-instantie met een gespecificeerde initiële capaciteit en een gespecificeerde belastingsfactor.

Syntaxis:

HashMap hm = new HashMap(int initialCapacity, float loadFactor);>

Voorbeeld

Java

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

4. HashMap (kaartkaart)

Het creëert een exemplaar van HashMap met dezelfde toewijzingen als de opgegeven kaart.

HashMap hm = nieuwe HashMap(kaartkaart);

Java

tekenreeks Java bevat

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}>

Verschillende bewerkingen uitvoeren op HashMap

1. Elementen toevoegen in HashMap op Java

Om een ​​element aan de kaart toe te voegen, kunnen we de neerzetten() methode. De invoegvolgorde blijft echter niet behouden in de Hashmap. Intern wordt voor elk element een aparte hash gegenereerd en op basis van deze hash worden de elementen geïndexeerd om het efficiënter te maken.

Java

>

>

Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}>

2. Elementen wijzigen in HashMap in Java

Als we na het toevoegen van de elementen het element willen wijzigen, kan dit worden gedaan door het element opnieuw toe te voegen met de neerzetten() methode. Omdat de elementen op de kaart worden geïndexeerd met behulp van de sleutels, kan de waarde van de sleutel worden gewijzigd door eenvoudigweg de bijgewerkte waarde in te voeren voor de sleutel waarvoor we deze willen wijzigen.

Java

>

>

Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}>

3. Element verwijderen uit Java HashMap

Om een ​​element van de kaart te verwijderen, kunnen we de verwijderen() methode. Deze methode neemt de sleutelwaarde en verwijdert de toewijzing voor een sleutel uit deze kaart als deze aanwezig is op de kaart.

Java

>

>

shweta tiwari-acteur

Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}>

4. Doorkruisen van Java HashMap

We kunnen de Iterator-interface gebruiken om elke structuur van het Collection Framework te doorlopen. Omdat Iterators met één type gegevens werken, gebruiken we Entry om de twee afzonderlijke typen om te zetten in een compatibel formaat. Vervolgens drukken we met behulp van de next()-methode de vermeldingen van HashMap af.

Java

>

>

Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>

Complexiteit van HashMap in Java

HashMap biedt constante tijdscomplexiteit voor basisbewerkingen, get en put als de hash-functie correct is geschreven en de elementen correct over de buckets worden verdeeld. Iteratie via HashMap is afhankelijk van de capaciteit van HashMap en het aantal sleutelwaardeparen. Kortom, het is recht evenredig met de capaciteit + grootte. Capaciteit is het aantal buckets in HashMap. Het is dus geen goed idee om in eerste instantie een groot aantal buckets in HashMap te bewaren.

Belangrijke kenmerken van HashMap

Om toegang te krijgen tot een waarde moet men de sleutel ervan kennen. HashMap staat bekend als HashMap omdat het gebruik maakt van een techniek genaamd Hashing. Hashing is een techniek waarbij een grote String wordt omgezet in een kleine String die dezelfde String vertegenwoordigt. Een kortere waarde helpt bij het indexeren en sneller zoeken. HashSet maakt ook intern gebruik van HashMap.
Een paar belangrijke kenmerken van HashMap zijn:

• HashMap is een onderdeel van het java.util-pakket.
• HashMap breidt een abstracte klasse AbstractMap uit die ook een onvolledige implementatie van de Map-interface biedt.
• Het implementeert ook een Kloonbaar En Serialiseerbaar interfaces. K en V in de bovenstaande definitie vertegenwoordigen respectievelijk Sleutel en Waarde.
• HashMap staat geen dubbele sleutels toe, maar wel dubbele waarden. Dat betekent dat een enkele sleutel niet meer dan 1 waarde kan bevatten, maar dat meer dan 1 sleutel één enkele waarde kan bevatten.
• HashMap staat ook een nulsleutel toe, maar slechts één keer en meerdere nulwaarden.
• Deze klasse geeft geen garanties over de volgorde van de kaart; het garandeert met name niet dat de bestelling in de loop van de tijd constant zal blijven. Het is ongeveer gelijk aan HashTable, maar is niet gesynchroniseerd.

Interne structuur van HashMap

Intern bevat HashMap een array van Node en een node wordt weergegeven als een klasse die 4 velden bevat:

1. int. hasj
2. K-sleutel
3. V-waarde
4. Knooppunt volgende

Het is duidelijk dat het knooppunt een verwijzing naar zijn eigen object bevat. Het is dus een gekoppelde lijst.

Hash kaart:

Knooppunt:

Prestaties van HashMap

De prestaties van HashMap zijn afhankelijk van 2 parameters die als volgt worden genoemd:

1. Initiële capaciteit
2. Ladingsfactor

1. Initiële capaciteit – Het is de capaciteit van HashMap op het moment dat het werd gemaakt (het is het aantal buckets dat een HashMap kan bevatten wanneer de HashMap wordt geïnstantieerd). In Java is het aanvankelijk 2^4=16, wat betekent dat het 16 sleutel-waardeparen kan bevatten.

2. Belastingsfactor – Het is de procentuele waarde van de capaciteit waarna de capaciteit van Hashmap moet worden vergroot (het is het percentage vulling van emmers waarna Rehashing plaatsvindt). In Java is dit standaard 0,75f, wat betekent dat het opnieuw hashen plaatsvindt nadat 75% van de capaciteit is gevuld.

3. Drempel – Het is het product van de belastingsfactor en de initiële capaciteit. In Java is dit standaard (16 * 0,75 = 12). Dat wil zeggen, het herhashing vindt plaats na het invoegen van 12 sleutel-waardeparen in de HashMap.

4. Herhalen – Het is het proces waarbij de capaciteit van de HashMap wordt verdubbeld nadat deze de drempel heeft bereikt. In Java blijft HashMap (standaard) opnieuw hashen in de volgende volgorde: 2^4, 2^5, 2^6, 2^7, .... spoedig.

Als de initiële capaciteit hoger wordt gehouden, zal er nooit opnieuw worden gehasht. Maar door het hoger te houden, wordt de tijdscomplexiteit van iteratie groter. Het moet dus heel slim worden gekozen om de prestaties te verbeteren. Er moet rekening worden gehouden met het verwachte aantal waarden om de initiële capaciteit in te stellen. De meest geprefereerde beladingsfactorwaarde is 0,75, wat een goede deal oplevert tussen tijd- en ruimtekosten. De waarde van de belastingsfactor varieert tussen 0 en 1.

Opmerking: Vanaf Java 8 is Java begonnen met het gebruik van Self Balancing BST in plaats van een gekoppelde lijst voor chaining. Het voordeel van zelfbalancerende bst is dat we in het ergste geval (wanneer elke sleutel naar hetzelfde slot verwijst) de zoektijd O(Log n) krijgt.

Gesynchroniseerde HashMap

Er wordt verteld dat HashMap niet gesynchroniseerd is, dat wil zeggen dat meerdere threads er tegelijkertijd toegang toe hebben. Als meerdere threads tegelijkertijd toegang hebben tot deze klasse en ten minste één thread deze structureel manipuleert, is het noodzakelijk om deze extern te synchroniseren. Dit wordt gedaan door een object te synchroniseren dat de kaart inkapselt. Als een dergelijk object niet bestaat, kan het rond Collections.synchronizedMap() worden gewikkeld om HashMap gesynchroniseerd te maken en onbedoelde niet-gesynchroniseerde toegang te voorkomen. Zoals in het volgende voorbeeld:

Map m = Collections.synchronizedMap(new HashMap(...));>

Nu is de kaart m gesynchroniseerd. Iterators van deze klasse zijn feilloos als er enige structuurwijziging wordt aangebracht na het maken van de iterator, op welke manier dan ook, behalve via de verwijdermethode van de iterator. Als een iterator mislukt, genereert deze ConcurrentModificationException.

Toepassingen van HashMap:

HashMap is voornamelijk de implementatie van hashing. Het is handig als we een efficiënte implementatie van zoek-, invoeg- en verwijderbewerkingen nodig hebben. Raadpleeg de toepassingen van hashing voor details.

Methoden in HashMapasssociate

• K – Het type sleutels op de kaart.
• IN – Het type waarden dat op de kaart in kaart is gebracht.

Methoden overgenomen van klasse java.util.AbstractMap

Methoden overgenomen van interface java.util.Map

Voordelen van Java HashMap

• Snel ophalen: HashMaps bieden constante tijdtoegang tot elementen, wat betekent dat het ophalen en invoegen van elementen erg snel gaat.
• Efficiënte opslag : HashMaps gebruikt een hashfunctie om sleutels toe te wijzen aan indices in een array. Dit maakt het snel opzoeken van waarden op basis van sleutels en efficiënte opslag van gegevens mogelijk.
• Flexibiliteit : HashMaps maken null-sleutels en -waarden mogelijk en kunnen sleutel-waardeparen van elk gegevenstype opslaan.
• Makkelijk te gebruiken : HashMaps hebben een eenvoudige interface en kunnen eenvoudig in Java worden geïmplementeerd.
• Geschikt voor grote datasets : HashMaps kan grote datasets verwerken zonder te vertragen.

Nadelen van Java HashMap

• Ongeordend : HashMaps zijn niet geordend, wat betekent dat de volgorde waarin elementen aan de kaart worden toegevoegd niet behouden blijft.
• Niet draadveilig : HashMaps zijn niet thread-safe, wat betekent dat als meerdere threads tegelijkertijd toegang hebben tot dezelfde hashmap, dit kan leiden tot inconsistenties in de gegevens.
• De prestaties kunnen afnemen : In sommige gevallen, als de hashfunctie niet correct is geïmplementeerd of als de belastingsfactor te hoog is, kunnen de prestaties van een HashMap verslechteren.
• Complexer dan arrays of lijsten : HashMaps kunnen complexer zijn om te begrijpen en te gebruiken dan eenvoudige arrays of lijsten, vooral voor beginners.
• Hoger geheugengebruik : Omdat HashMaps een onderliggende array gebruiken, kunnen ze meer geheugen gebruiken dan andere datastructuren zoals arrays of lijsten. Dit kan een nadeel zijn als geheugengebruik een probleem is.

Lees ook

• Hashmap versus Treemap
• Hashmap versus HashTabel
• Recente artikelen over Java HashMap

Veelgestelde vragen over Java HashMap

1. Wat is een HashMap in Java?

HashMap in Java is de klasse uit het verzamelframework die sleutel-waardeparen erin kan opslaan.

2. Waarom HashMap gebruiken in Java?

HashMap in Java wordt gebruikt voor het opslaan van sleutel-waardeparen waarbij elke sleutel uniek is.

3. Wat is het voordeel van HashMap?

HashMap wordt gebruikt omdat het functies biedt zoals:

• Snel ophalen
• Efficiënte opslag
• Flexibel in gebruik
• Makkelijk te gebruiken
• Geschikt voor grote datasets