Afgezien van het feit dat HashSetgeen dubbele waarden toestaat, wat is het verschil tussen HashMapen HashSet?

Ik bedoel qua implementatie? Het is een beetje vaag omdat beide hashtabellengebruiken om waarden op te slaan.

Antwoord 1, autoriteit 100%

Het zijn totaal verschillende constructies. Een HashMapis een implementatie van Map. Een kaartkoppelt sleutels aan waarden. Het opzoeken van de sleutel gebeurt met behulp van de hash.

Aan de andere kant is een HashSeteen implementatie van Set. Een Setis ontworpen om te passen bij het wiskundige model van een stel. Een HashSetgebruikt wel een HashMapom de implementatie te ondersteunen, zoals je hebt opgemerkt. Het implementeert echter een geheel andere interface.

Als u op zoek bent naar de beste Collectionvoor uw doeleinden, is deze Tutorialis een goed beginpunt. Als je echt wilt weten wat er aan de hand is, is daar ook een boek voor.

Antwoord 2, autoriteit 94%

HashSet is een set, b.v. {1,2,3,4,5}

HashMap is een sleutel -> waarde(sleutel tot waarde) kaart, b.v. {a -> 1, b -> 2, c -> 2, d -> 1}

Merk in mijn voorbeeld hierboven op dat er in de HashMap geen dubbele sleutels mogen zijn, maar het kan dubbele waarden hebben.

In de HashSet mogen er geen dubbele elementen zijn.

Antwoord 3, autoriteit 44%

HashSet

1. HashSet-klasse implementeert de Set-interface
2. In HashSet slaan we objecten op (elementen of waarden)
   bijv. Als we een HashSet van string-elementen hebben, kan het a . weergeven
   set HashSet-elementen: { Hallo , Hi , Bye , Run }
3. HashSet staat geen dubbele elementen toe die jou betekenen
   kan geen dubbele waarden opslaan in HashSet.
4. HashSet staat toe om een ​​enkele null-waarde te hebben.

5. HashSet is niet gesynchroniseerd, wat betekent dat ze niet geschikt zijn voor thread-veilige bewerkingen totdat ze expliciet worden gesynchroniseerd.[similarity]

                        add      contains next     notes
   HashSet               O(1)     O(1)     O(h/n)   h is the table 
   

HashMap

1. HashMap-klasse implementeert de kaartinterface
2. HashMap is
   gebruikt voor het opslaan van sleutel & waardeparen. Kortom, het houdt de
   in kaart brengen van sleutel & waarde (de klasse HashMap is ongeveer gelijk aan
   Hashtable, behalve dat het niet gesynchroniseerd is en nulls toestaat.)
   is hoe je HashMap-elementen zou kunnen vertegenwoordigen als het een integer-sleutel heeft
   en waarde van String type: b.v. {1-> Hallo , 2-> Hallo , 3-> Tot ziens ,
   4-> Uitvoeren }
3. HashMap staat geen dubbele sleutels toe, maar wel dubbele waarden.
4. HashMap staat een enkele null-sleutel en een willekeurig aantal null-waarden toe.

5. HashMap is niet gesynchroniseerd, wat betekent dat ze niet geschikt zijn voor thread-veilige bewerkingen totdat ze expliciet worden gesynchroniseerd.[similarity]

                         get      containsKey next     Notes
    HashMap               O(1)     O(1)        O(h/n)   h is the table 
   

Raadpleeg dit artikelvoor meer informatie.

p>

Antwoord 4, autoriteit 24%

Het is echt jammer dat beide namen beginnen met Hash. Dat is het minst belangrijke deel van hen. De belangrijke delen komen na de Hash– de Seten Map, zoals anderen al hebben aangegeven. Wat ze zijn, zijn respectievelijk een Set– een ongeordende verzameling – en een Map– een verzameling met toegang via sleutels. Ze zijn toevallig geïmplementeerd met hashes – daar komen de namen vandaan – maar hun essentie zit verborgen achter dat deel van hun namen.

Laat u niet verwarren door hun namen; het zijn totaal verschillende dingen.

Antwoord 5, autoriteit 4%

De HashSetimplementeert intern HashMap. Als je de interne implementatieziet, worden de in HashSet ingevoegde waarden opgeslagen als sleutels in de HashMap en de waarde is een Dummy-object van de klasse Object.
Het verschil tussen HashMap en HashSet is:-

1. HashMapbevat sleutelwaardeparen en elke waarde is toegankelijk via een sleutel waarbij HashSet elke keer moet worden herhaald omdat er geen get-methode is.
2. HashMapimplementeert kaartinterface en staat één null-waarde toe als sleutel en meerdere null-waarden als waarden. Waar als HashSetSet-interface implementeert, staat slechts één null-waarde en geen gedupliceerde waarden. (Onthoud dat één null-sleutel is toegestaan ​​in de HashMap-sleutel, dus één null-waarde in HashSet omdat HashSet HashMap intern implementeert).
3. HashSeten HashMapbehouden de volgorde van invoegen niet tijdens iteratie.

Antwoord 6, autoriteit 2%

HashSet stelt ons in staat om objecten in de set op te slaan, terwijl HashMap ons in staat stelt om objecten op te slaan op basis van sleutel en waarde. Elk object of opgeslagen object heeft een sleutel.

Antwoord 7

Zoals de namen al doen vermoeden, is een HashMapeen associatieve Map(toewijzing van een sleutel aan een waarde), een HashSetis slechts een Instellen.

Antwoord 8

Verschillen tussen HashSet en HashMap in Java

1)Het eerste en belangrijkste verschil tussen HashMap en HashSet is dat HashMap een implementatie is van de kaartinterface, terwijl HashSet een implementatie is van de Set-interface, wat betekent dat HashMap een op sleutelwaarden gebaseerde gegevensstructuur is en HashSet garandeert uniekheid door geen duplicaten toe te staan. In werkelijkheid is HashSet een wrapper rond HashMap in Java, als je kijkt naar de code van de add (E e) -methode van HashSet.java, zie je de volgende code:

public boolean add(E e) 
{
    return map.put(e, PRESENT)==null;
}

waarbij het plaatsen van Object op de kaart als sleutel en waarde een laatste object AANWEZIG is dat een dummy is.

2)Het tweede verschil tussen HashMap en HashSet is dat we de methode add() gebruiken om elementen in Set te plaatsen, maar we gebruiken de methode put() om de sleutel en waarde in HashMap in Java in te voegen.

3)HashSet staat slechts één null-sleutel toe, maar HashMap kan één null-sleutel + meerdere null-waarden toestaan.

Dat is allemaal op het verschil tussen HashSet en HashMap in Java. Samengevat zijn HashSet en HashMap twee verschillende soorten verzamelingen, waarvan de ene Set is en de andere Map.

Antwoord 9

Verschillen tussen HashSet en HashMap in Java

HashSet gebruikt intern HashMap om objecten op te slaan. Wanneer de add(String)-methode wordt genoemd, roept het de HahsMap put(key,value)-methode aan waarbij key=String-object & value=new Object(Dummy).dus het onderhoudt geen duplicaten omdat sleutels niets anders zijn dan Value Object.

de objecten die als sleutel zijn opgeslagen in Hashset/HashMap moeten de hashcode overschrijven & gelijk is aan overeenkomst.

Sleutels die worden gebruikt om waarde-objecten in HashMap te openen/op te slaan, moeten als definitief worden gedeclareerd, omdat wanneer het wordt gewijzigd het waarde-object niet kan worden gelokaliseerd & geeft nul terug.

Antwoord 10

Een HashMapis om objecten toe te voegen, op te halen, te verwijderen, … die zijn geïndexeerd door een aangepaste sleutel van elk type.
Een HashSetis om elementen toe te voegen, elementen te verwijderen en te controleren of elementen aanwezig zijn door hun hashes te vergelijken.

Dus een HashMap bevat de elementen en een HashSet onthoudt hun hashes.

Antwoord 11

Verschillen:
met betrekking tot hiërarchie:
HashSet implementeert Set.
HashMap implementeert Map en slaat een toewijzing van sleutels en waarden op.

Het gebruik van HashSet en HashMap met betrekking tot de database zou u helpen de betekenis van elk te begrijpen.

HashSet:wordt over het algemeen gebruikt voor het opslaan van unieke verzamelingsobjecten.
Bijv: het kan worden gebruikt als implementatieklasse voor het opslaan van veel-op-een-relaties tussen
klasse-item en klasse-bod waar (item heeft veel biedingen)
HashMap:wordt gebruikt om een ​​sleutel toe te wijzen aan value.the waarde kan null zijn of een object /lijst met objecten (wat op zichzelf een object is).

Antwoord 12

Een HashSetis geïmplementeerd in termen van een HashMap. Het is een mapping tussen de sleutel en een PRESENT object.

Antwoord 13

Een HashSet gebruikt intern een HashMap om zijn invoer op te slaan. Elk item in de interne HashMap wordt gecodeerd door een enkel object, dus alle items worden in dezelfde bucket gehasht. Ik kan me niet herinneren wat de interne HashMap gebruikt om zijn waarden op te slaan, maar het maakt niet echt uit, omdat die interne container nooit dubbele waarden zal bevatten.

EDIT: om de opmerking van Matthew aan te pakken, hij heeft gelijk; Ik had het achterstevoren. De interne HashMap is gecodeerd met de objecten waaruit de Set-elementen bestaan. De waarden van de HashMap zijn een object dat gewoon is opgeslagen in de HashMap-buckets.

Antwoord 14

HashMapis een Map-implementatie, die dubbele waardentoelaat, maar geen dubbele sleutels.. Voor het toevoegen van een object is een sleutel/waarde-paar vereist. Null-sleutels en Null-waarden zijn toegestaan. bv:

{The->3,world->5,is->2,nice->4}

HashSetis een Set-implementatie, die duplicaten niet toestaat. Als u probeerde een duplicaat object toe te voegen, een aanroep naar public boolean add(Object o)methode, dan blijft de set ongewijzigd en retourneert false. bv:

[De,wereld,is,leuk]

Antwoord 15

je hebt vrijwel je eigen vraag beantwoord – hashset staat geen dubbele waarden toe. het zou triviaal zijn om een ​​hashset te bouwen met behulp van een backing-hashmap (en alleen een controle om te zien of de waarde al bestaat). ik denk dat de verschillende java-implementaties dat doen, of een aangepaste code implementeren om het efficiënter te doen.

Antwoord 16

In principe moet de gebruiker in HashMap zowel Sleutel als Waarde opgeven, terwijl u in HashSet alleen Waarde opgeeft, de Sleutel wordt automatisch afgeleid van Waarde met behulp van de hash-functie. Dus na zowel Key als Value te hebben, kan HashSet intern als HashMap worden opgeslagen.

Antwoord 17

HashSet en HashMap slaan beide op, het verschil is dat je in HashMap een sleutel kunt specificeren, terwijl in HashSet de sleutel afkomstig is van de hash-code van het object

Antwoord 18

HashMapsstaan ​​één null-sleutel en null-waarden toe. Ze zijn niet gesynchroniseerd, wat de efficiëntie verhoogt. Indien nodig kunt u ze synchroniseren met Collections.SynchronizedMap()

Hashtablesstaan ​​geen null-sleutels toe en worden gesynchroniseerd.

Antwoord 19

Het belangrijkste verschil tussen beide kun je als volgt vinden:

HashSet

• Het staat geen dubbele sleutels toe.
• Zelfs het is niet gesynchroniseerd, dus dit zal betere prestaties leveren.
• Het staat een null-sleutel toe.
• HashSet kan worden gebruikt als u een unieke lijst wilt bijhouden.
• HashSet implementeert Set-interface en wordt ondersteund door de hashtabel (eigenlijk HashMap-instantie).
• HashSet slaat objecten op.
• HashSet staat geen dubbele elementen toe, maar null-waarden zijn toegestaan.
• Deze interface garandeert niet dat de volgorde in de loop van de tijd constant blijft.

HashMap

• Het staat dubbele sleutels toe.
  Het is niet gesynchroniseerd, dus dit zal betere prestaties leveren.
• HashMap handhaaft de invoegvolgorde niet.
• De volgorde wordt bepaald door de Hash-functie.
• Het is niet veilig voor threads
• Het staat null toe voor zowel sleutel als waarde.
• Het staat één null-sleutel toe en zoveel null-waarden als je wilt.
• HashMap is een Hash-tabelgebaseerde implementatie van de kaartinterface.
• HashMap-winkelobject als sleutel- en waardepaar.
• HashMap staat geen dubbele sleutels toe, maar null-sleutels en waarden zijn toegestaan.
• Bestelling van het element is niet gegarandeerd voor overuren.

Antwoord 20

HashMap is een implementatie van de kaartinterface
HashSet is een implementatie van Set Interface

HashMap Slaat gegevens op in de vorm van een sleutelwaardepaar
HashSet Alleen objecten opslaan

Put-methode wordt gebruikt om elementen in kaart toe te voegen
Add-methode wordt gebruikt om element toe te voegen is Set

In hashmap wordt hashcodewaarde berekend met sleutelobject
Hier wordt lidobject gebruikt voor het berekenen van de hashcode-waarde die hetzelfde kan zijn voor twee objecten, dus de methode equal () wordt gebruikt om te controleren op gelijkheid als het false retourneert, wat betekent dat twee objecten verschillend zijn.

HashMap is sneller dan hashset omdat een unieke sleutel wordt gebruikt om toegang te krijgen tot het object
HashSet is langzamer dan Hashmap