Java HashSet klasse implementerer Set-grænsefladen, understøttet af en hash-tabel, som faktisk er en HashMap-instans. Der gives ingen garanti for iterationsrækkefølgen af hashsættene, hvilket betyder, at klassen ikke garanterer den konstante rækkefølge af elementer over tid. Denne klasse tillader null-elementet. Klassen tilbyder også konstant tidsydeevne for de grundlæggende operationer som tilføje, fjerne, indeholder og størrelse, forudsat at hash-funktionen spreder elementerne korrekt blandt spandene, hvilket vi skal se yderligere i artiklen.
Java HashSet-funktioner
Et par vigtige funktioner i HashSet er nævnt nedenfor:
- Redskaber Indstil grænseflade .
- Den underliggende datastruktur for HashSet er Hastbar .
- Da det implementerer Set Interface, er duplikerede værdier ikke tilladt.
- Objekter, som du indsætter i HashSet, er ikke garanteret at blive indsat i samme rækkefølge. Objekter indsættes baseret på deres hash-kode.
- NULL-elementer er tilladt i HashSet.
- HashSet implementerer også Serialiserbar og Kan klones grænseflader.
Erklæring om HashSet
public class HashSet extends AbstractSet implements Set, Cloneable, Serializable>
hvor OG er den type elementer, der er gemt i et HashSet.
HashSet Java Eksempel
Java
// Java program to illustrate the concept> // of Collection objects storage in a HashSet> import> java.io.*;> import> java.util.*;> > class> CollectionObjectStorage {> > >public> static> void> main(String[] args)> >{> >// Instantiate an object of HashSet> >HashSet set =>new> HashSet();> > >// create ArrayList list1> >ArrayList list1 =>new> ArrayList();> > >// create ArrayList list2> >ArrayList list2 =>new> ArrayList();> > >// Add elements using add method> >list1.add(>1>);> >list1.add(>2>);> >list2.add(>1>);> >list2.add(>2>);> >set.add(list1);> >set.add(list2);> > >// print the set size to understand the> >// internal storage of ArrayList in Set> >System.out.println(set.size());> >}> }> |
hashing i datastruktur
>
>Produktion:
1>
Før du gemmer et objekt, kontrollerer HashSet, om der er en eksisterende post ved hjælp af hashCode() og equals() metoder. I ovenstående eksempel betragtes to lister som ens, hvis de har de samme elementer i samme rækkefølge. Når du påberåber dig hashCode() metode på de to lister, ville de begge give den samme hash, da de er ens.
Bemærk: Det gør HashSet ikke gemme duplikerede varer , hvis du giver to objekter, der er lige store, gemmer den kun den første, her er den liste1.
Hierarkiet for HashSet er som følger:
Intern drift af et HashSet
Alle klasser i Set-grænsefladen er internt sikkerhedskopieret af Map. HashSet bruger HashMap til at gemme sit objekt internt. Du må undre dig over, at for at indtaste en værdi i HashMap har vi brug for et nøgle-værdi-par, men i HashSet sender vi kun én værdi.
Opbevaring i HashMap: Faktisk fungerer den værdi, vi indsætter i HashSet, som en nøgle til kortobjektet, og for dets værdi bruger java en konstant variabel. Så i nøgleværdi-parret vil alle værdier være ens.
Implementering af HashSet i Java doc
private transient HashMap map; // Constructor - 1 // All the constructors are internally creating HashMap Object. public HashSet() { // Creating internally backing HashMap object map = new HashMap(); } // Constructor - 2 public HashSet(int initialCapacity) { // Creating internally backing HashMap object map = new HashMap(initialCapacity); } // Dummy value to associate with an Object in Map private static final Object PRESENT = new Object();> Hvis vi ser på tilføje() metode for HashSet-klassen:
public boolean add(E e) { return map.put(e, PRESENT) == null; }> Vi kan bemærke, at add()-metoden i HashSet-klassen internt kalder sætte() metode til at bakke HashMap-objektet ved at sende det element, du har angivet, som en nøgle og konstant PRESENT som dets værdi. fjerne() Metoden fungerer også på samme måde. Det kalder internt fjernelsesmetoden for kortgrænsefladen.
public boolean remove(Object o) { return map.remove(o) == PRESENT; }> HashSet gemmer ikke kun unikke objekter, men også en unik samling af objekter synes godt om ArrayList , LinkedList , vektor ..osv.
Konstruktører af HashSet-klassen
For at oprette et HashSet skal vi oprette et objekt af HashSet-klassen. HashSet-klassen består af forskellige konstruktører, der muliggør oprettelse af HashSet. Følgende er de konstruktører, der er tilgængelige i denne klasse.
1. HashSet()
Denne konstruktør bruges til at bygge et tomt HashSet-objekt, hvor standardindledende kapacitet er 16 og standardbelastningsfaktoren er 0,75. Hvis vi ønsker at oprette et tomt HashSet med navnet hs, så kan det oprettes som:
HashSet hs = new HashSet();>
2. HashSet(int initialCapacity)
Denne konstruktør bruges til at bygge et tomt HashSet-objekt, hvor initialCapacity er angivet på tidspunktet for objektoprettelse. Her forbliver standard loadFactor 0,75.
HashSet hs = new HashSet(int initialCapacity);>
3. HashSet(int initialCapacity, float loadFactor)
Denne konstruktør bruges til at bygge et tomt HashSet-objekt, hvor initialCapacity og loadFactor er angivet på tidspunktet for objektoprettelse.
HashSet hs = new HashSet(int initialCapacity, float loadFactor);>
4. HashSet (Samling)
Denne konstruktør bruges til at bygge et HashSet-objekt, der indeholder alle elementerne fra den givne samling. Kort sagt bruges denne konstruktør, når en konvertering er nødvendig fra et samlingsobjekt til HashSet-objektet. Hvis vi ønsker at oprette et HashSet med navnet hs, kan det oprettes som:
HashSet hs = new HashSet(Collection C);>
Nedenfor er implementeringen af ovenstående emner:
Java
// Java program to Demonstrate Working> // of HashSet Class> > // Importing required classes> import> java.util.*;> > // Main class> // HashSetDemo> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty HashSet> >HashSet h =>new> HashSet();> > >// Adding elements into HashSet> >// using add() method> >h.add(>'India'>);> >h.add(>'Australia'>);> >h.add(>'South Africa'>);> > >// Adding duplicate elements> >h.add(>'India'>);> > >// Displaying the HashSet> >System.out.println(h);> >System.out.println(>'List contains India or not:'> >+ h.contains(>'India'>));> > >// Removing items from HashSet> >// using remove() method> >h.remove(>'Australia'>);> >System.out.println(>'List after removing Australia:'> >+ h);> > >// Display message> >System.out.println(>'Iterating over list:'>);> > >// Iterating over hashSet items> >Iterator i = h.iterator();> > >// Holds true till there is single element remaining> >while> (i.hasNext())> > >// Iterating over elements> >// using next() method> >System.out.println(i.next());> >}> }> |
>
>Produktion:
[South Africa, Australia, India] List contains India or not:true List after removing Australia:[South Africa, India] Iterating over list: South Africa India>
Metoder i HashSet
| METODE | BESKRIVELSE |
|---|---|
| tilføje (Og og) | Bruges til at tilføje det angivne element, hvis det ikke er til stede, hvis det er til stede, så returner falsk. |
| klar() | Bruges til at fjerne alle elementer fra sættet. |
| indeholder (Objekt o) | Bruges til at returnere sand, hvis et element er til stede i et sæt. |
| fjern (Objekt o) | Bruges til at fjerne elementet, hvis det er til stede i sæt. |
| iterator() | Bruges til at returnere en iterator over elementet i sættet. |
| er tom() | Bruges til at kontrollere, om sættet er tomt eller ej. Returnerer sand for tom og falsk for en ikke-tom betingelse for sæt. |
| størrelse() | Bruges til at returnere sættets størrelse. |
| klone() | Bruges til at lave en overfladisk kopi af sættet. |
Udførelse af forskellige operationer på HashSet
Lad os se, hvordan du udfører et par ofte brugte operationer på HashSet.
1. Tilføjelse af elementer i HashSet
For at tilføje et element til HashSet, kan vi bruge add() metoden. Indsættelsesrækkefølgen bibeholdes dog ikke i HashSet. Vi skal huske på, at duplikerede elementer ikke er tilladt, og alle duplikerede elementer ignoreres.
Eksempel
Java
// Java program to Adding Elements to HashSet> > // Importing required classes> import> java.io.*;> import> java.util.*;> > // Main class> // AddingElementsToHashSet> class> GFG {> > >// Method 1> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating an empty HashSet of string entities> >HashSet hs =>new> HashSet();> > >// Adding elements using add() method> >hs.add(>'Geek'>);> >hs.add(>'For'>);> >hs.add(>'Geeks'>);> > >// Printing all string el=ntries inside the Set> >System.out.println(>'HashSet elements : '> + hs);> >}> }> |
>
>Produktion:
HashSet elements : [Geek, For, Geeks]>
2. Fjernelse af elementer i HashSet
Værdierne kan fjernes fra HashSet ved hjælp af remove() metoden.
Eksempel
Java
// Java program Illustrating Removal Of Elements of HashSet> > // Importing required classes> import> java.io.*;> import> java.util.*;> > // Main class> // RemoveElementsOfHashSet> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating an> >HashSet hs =>new> HashSet();> > >// Adding elements to above Set> >// using add() method> >hs.add(>'Geek'>);> >hs.add(>'For'>);> >hs.add(>'Geeks'>);> >hs.add(>'A'>);> >hs.add(>'B'>);> >hs.add(>'Z'>);> > >// Printing the elements of HashSet elements> >System.out.println(>'Initial HashSet '> + hs);> > >// Removing the element B> >hs.remove(>'B'>);> > >// Printing the updated HashSet elements> >System.out.println(>'After removing element '> + hs);> > >// Returns false if the element is not present> >System.out.println(>'Element AC exists in the Set : '> >+ hs.remove(>'AC'>));> >}> }> |
>
>Produktion:
Initial HashSet [A, B, Geek, For, Geeks, Z] After removing element [A, Geek, For, Geeks, Z] Element AC exists in the Set : false>
3. Itererer gennem HashSet
Gentag gennem elementerne i HashSet ved hjælp af iterator()-metoden. Den mest berømte er også at bruge forbedret til loop.
Eksempel
Kodeblok
ProduktionA, B, Geek, For, Geeks, Z, A, B, Geek, For, Geeks, Z,>
Tidskompleksitet af HashSet-operationer: Den underliggende datastruktur for HashSet er hashbar. Så amortiser (gennemsnitlig eller sædvanlig sag) tidskompleksitet for tilføjelse, fjernelse og opslag (indeholder metode) drift af HashSet tager O(1) tid.
Ydeevne af HashSet
HashSet udvider Abstract Set-klassen og implementerer Sæt , Klonbar , og Serialiserbar grænseflader, hvor E er den type elementer, der vedligeholdes af dette sæt. Den direkte kendte underklasse af HashSet er LinkedHashSet.
For nu at opretholde konstant tidsydeevne kræver iteration over HashSet tid proportional med summen af HashSet-forekomstens størrelse (antallet af elementer) plus kapaciteten af den understøttende HashMap-instans (antallet af buckets). Det er derfor meget vigtigt ikke at indstille den indledende kapacitet for højt (eller belastningsfaktoren for lav), hvis iterationsydelsen er vigtig.
- Oprindelig kapacitet: Den oprindelige kapacitet betyder antallet af buckets, når hashtabellen (HashSet bruger internt hashbar datastruktur) oprettes. Antallet af spande øges automatisk, hvis den aktuelle størrelse bliver fuld.
- Belastningsfaktor: Belastningsfaktoren er et mål for, hvor fyldt HashSet'et må blive, før dets kapacitet automatisk øges. Når antallet af poster i hash-tabellen overstiger produktet af belastningsfaktoren og den aktuelle kapacitet, bliver hash-tabellen rehashed (det vil sige interne datastrukturer genopbygges), så hashtabellen har cirka det dobbelte af antallet af buckets.
Number of stored elements in the table Load Factor = ----------------------------------------- Size of the hash table>
Eksempel: Hvis den interne kapacitet er 16, og belastningsfaktoren er 0,75, vil antallet af skovle automatisk blive øget, når bordet har 12 elementer i sig.
Effekt på ydeevne:
Belastningsfaktor og startkapacitet er to hovedfaktorer, der påvirker ydelsen af HashSet-operationer. En belastningsfaktor på 0,75 giver meget effektiv ydeevne med hensyn til tid og rumkompleksitet. Hvis vi øger belastningsfaktorværdien mere end det, vil hukommelsesomkostningerne blive reduceret (fordi det vil reducere intern genopbygningsoperation), men det vil påvirke tilføjelses- og søgeoperationen i hashtabellen. For at reducere rehashing-operationen bør vi vælge den indledende kapacitet med omhu. Hvis startkapaciteten er større end det maksimale antal indtastninger divideret med belastningsfaktoren, vil der aldrig forekomme nogen rehash-operation.
Bemærk: Implementeringen i et HashSet er ikke synkroniseret i den forstand, at hvis flere tråde får adgang til et hashsæt samtidigt, og mindst en af trådene ændrer sættet, skal det synkroniseres eksternt. Dette opnås typisk ved at synkronisere på et objekt, der naturligt indkapsler sættet. Hvis der ikke findes et sådant objekt, skal sættet pakkes ved hjælp af Collections.synchronizedSet-metoden. Dette gøres bedst på oprettelsestidspunktet for at forhindre utilsigtet usynkroniseret adgang til sættet som vist nedenfor:
Set s = Collections.synchronizedSet(new HashSet(…));
Metoder brugt med HashSet
1. Metoder arvet fra klassen java.util.AbstractSet
| Metode | Beskrivelse |
|---|---|
| lige med() | Bruges til at verificere ligheden mellem et objekt og et HashSet og sammenligne dem. Listen returnerer kun sand, hvis begge HashSet indeholder de samme elementer, uanset rækkefølge. |
| hashkode() | Returnerer hash-kodeværdien for dette sæt. |
| removeAll (samling) | Denne metode bruges til at fjerne alle de elementer fra samlingen, som er til stede i sættet. Denne metode returnerer sand, hvis dette sæt ændres som følge af opkaldet. |
2. Metoder nedarvet fra klassen java.util.AbstractCollection
| METODE | BESKRIVELSE |
|---|---|
| addAll (samling) | Denne metode bruges til at tilføje alle elementerne fra den nævnte samling til det eksisterende sæt. Elementerne tilføjes tilfældigt uden at følge nogen specifik rækkefølge. |
| indeholder alle (samling) | Denne metode bruges til at kontrollere, om sættet indeholder alle de elementer, der er til stede i den givne samling eller ej. Denne metode returnerer sand, hvis sættet indeholder alle elementerne, og returnerer falsk, hvis nogen af elementerne mangler. |
| retainAll (samling) | Denne metode bruges til at bevare alle de elementer fra sættet, som er nævnt i den givne samling. Denne metode returnerer sand, hvis dette sæt ændres som følge af opkaldet. |
| toArray() | Denne metode bruges til at danne en række af de samme elementer som sættet. |
| toString() | ToString()-metoden i Java HashSet bruges til at returnere en strengrepræsentation af elementerne i HashSet-samlingen. |
3. Metoder erklæret i interface java.util.Collection
| METODE | BESKRIVELSE |
|---|---|
| parallelStream() | Returnerer en muligvis parallel strøm med denne samling som kilde. |
| removeIf? (prædikatfilter) | Fjerner alle de elementer i denne samling, der opfylder det givne prædikat. |
| strøm() | Returnerer en sekventiel stream med denne samling som kilde. |
| toArray? (IntFunction generator) | Returnerer et array, der indeholder alle elementerne i denne samling, ved at bruge den medfølgende generatorfunktion til at allokere det returnerede array. |
4. Metoder erklæret i grænsefladen java.lang.Iterable
| METODE | BESKRIVELSE |
|---|---|
| til hver? (Forbrugerhandling) | Udfører den givne handling for hvert element i Iterable, indtil alle elementer er blevet behandlet, eller handlingen kaster en undtagelse. |
5. Metoder erklæret i interface java.util.Set
| METODE | BESKRIVELSE |
|---|---|
| addAll? (Samling c) | Tilføjer alle elementerne i den angivne samling til dette sæt, hvis de ikke allerede er til stede (valgfri handling). |
| indeholder alle? (Samling c) | Returnerer sand, hvis dette sæt indeholder alle elementerne i den angivne samling. |
| er lig med? (Objekt o) | Sammenligner det angivne objekt med dette sæt for lighed. |
| hashCode() | Returnerer hash-kodeværdien for dette sæt. |
| fjern alle? (Samling c) | Fjerner fra dette sæt alle dets elementer, der er indeholdt i den angivne samling (valgfri handling). |
| beholdeAlle? (Samling c) | Beholder kun de elementer i dette sæt, der er indeholdt i den angivne samling (valgfri drift). |
| toArray() | Returnerer en matrix, der indeholder alle elementerne i dette sæt. |
| toArray?(T[] a) | Returnerer en matrix, der indeholder alle elementerne i dette sæt; runtime-typen for den returnerede matrix er den for den angivne matrix. |
Ofte stillede spørgsmål i HashSet i Java
Q1. Hvad er HashSet i Java?
Svar:
HashSet er en type klasse, som udvider AbstractSet og implementerer Set-grænseflader.
Q2. Hvorfor bruges HashSet?
Svar:
HashSet bruges til at undgå duplikerede data og til at finde værdi med den hurtige metode.
Q3. Forskelle mellem HashSet og HashMap.
Svar:
| Basis | HashSet | HashMap |
|---|---|---|
| Implementering | HashSet implementerer en Set-grænseflade. | HashMap implementerer en storesMap-grænseflade. |
| Dubletter | HashSet tillader ikke duplikerede værdier. | HashMap gemmer nøgle- og værdiparrene, og det tillader ikke duplikerede nøgler. Hvis nøglen er dublet, erstattes den gamle nøgle med den nye værdi. |
| Antal genstande under opbevaring af genstande | HashSet kræver kun ét objekt add(Object o). | HashMap kræver to objekter sat (K-tast, V-værdi) for at tilføje et element til HashMap-objektet. |
| Dummy værdi | HashSet bruger internt HashMap til at tilføje elementer. I HashSet fungerer argumentet sendt i add(Object)-metoden som nøgle K. Java associerer internt en dummy-værdi for hver værdi, der sendes i add(Object)-metoden. | HashMap har ikke noget begreb om dummy-værdi. |
| Lagring eller tilføjelse af en mekanisme | HashSet bruger internt HashMap-objektet til at gemme eller tilføje objekterne. | HashMap bruger internt hashing til at gemme eller tilføje objekter |
| Hurtigere | HashSet er langsommere end HashMap. | HashMap er hurtigere end HashSet. |
| Indskud | HashSet bruger add() metoden til at tilføje eller gemme data. | HashMap bruger put()-metoden til lagring af data. |
| Eksempel | HashSet er et sæt, f.eks. {1, 2, 3, 4, 5, 6, 7}. | HashMap er et nøgle -> værdipar(nøgle til værdi) kort, f.eks. {a -> 1, b -> 2, c -> 2, d -> 1}. |
Q4. Forskelle mellem HashSet og TreeSet i Java.
Svar:
| Basis | HashSet | Træsæt markdown fodnoter |
|---|---|---|
| Hastighed og interne implementere, kaste handling | Til handlinger som at søge, indsætte og slette. Det tager i gennemsnit konstant tid for disse operationer. HashSet er hurtigere end TreeSet. HashSet er implementeret ved hjælp af en hash-tabel. | TreeSet tager O(Log n) for at søge, indsætte og slette, hvilket er højere end HashSet. Men TreeSet holder sorterede data. Det understøtter også operationer som højere() (Returnerer mindst højere element), floor(), loft() osv. Disse operationer er også O(Log n) i TreeSet og understøttes ikke i HashSet. TreeSet implementeres ved hjælp af et selvbalancerende binært søgetræ (rød-sort træ). TreeSet er understøttet af TreeMap i Java. |
| Bestilling | Elementer i HashSet er ikke bestilt. | TreeSet vedligeholder objekter i sorteret rækkefølge defineret af enten Comparable- eller Comparator-metoden i Java. TreeSet-elementer er som standard sorteret i stigende rækkefølge. Det tilbyder flere metoder til at håndtere det bestilte sæt som first(), last(), headSet(), tailSet() osv. |
| Nul objekt | HashSet tillader null-objektet. | TreeSet tillader ikke null Object og kaster NullPointerException, hvorfor, er fordi TreeSet bruger compareTo() metoden til at sammenligne nøgler, og compareTo() vil kaste java.lang.NullPointerException. |
| Sammenligning | HashSet bruger metoden equals() til at sammenligne to objekter i sættet og til at detektere dubletter. | TreeSet bruger metoden compareTo() til samme formål. Hvis equals() og compareTo() ikke er konsistente, dvs. for to lige store objekter skal lig returnere sand, mens compareTo() skal returnere nul, så vil det bryde kontrakten for Set-grænsefladen og tillade dubletter i Set-implementeringer som TreeSet |