Over de klasse LinkedHashSet in Java gesproken, we moeten vermelden dat deze de Set- interface implementeert. LinkedHashSet maakt een verzameling die elementen in een hashtabel opslaat, maar de invoegvolgorde van elementen handhaaft in tegenstelling tot zijn HashSet- tegenhanger.
Wat is ingesteld in Java
Laten we er even aan herinneren dat de Set- interface een set (set) definieert. Het breidt Collection uit en definieert het gedrag van collecties die geen dubbele elementen toestaan. De methode add() retourneert dus false als er wordt geprobeerd een duplicaatelement aan de set toe te voegen. De interface definieert zelf geen aanvullende methoden. De Set- interface zorgt voor de uniciteit van opgeslagen objecten, uniciteit wordt bepaald door de implementatie van de equals() methode. Als objecten van de gemaakte klasse aan de Set worden toegevoegd , is het daarom wenselijk om de methode equals() te overschrijven.
LinkedHashSet-klasse
Voordat we het hebben over de LinkedHashSet- klasse, moeten we de naaste verwant, de HashSet- klasse, noemen. HashSet implementeert de Set- interface. Het creëert een verzameling die de elementen in een hashtabel opslaat. De elementen van een hashtabel worden opgeslagen als sleutel-waardeparen. De sleutel specificeert de cel (of het segment) om de waarde op te slaan. De inhoud van de sleutel wordt gebruikt om een unieke waarde te bepalen die een hashcode wordt genoemd. We kunnen een hashcode zien als een objectidentificatie, hoewel deze niet uniek hoeft te zijn. Deze hashcode dient tevens als index waarin de gegevens behorende bij de sleutel worden opgeslagen. De Java-klasse LinkedHashSet breidt HashSet uit zonder nieuwe methoden toe te voegen.Met LinkedHashSet kunt u snel controleren op het bestaan van een vermelding, net als HashSet , maar bevat een geordende lijst binnenin. Dit betekent dat het de invoegvolgorde van de elementen opslaat. Met andere woorden, LinkedHashSet onderhoudt een gekoppelde lijst met set-elementen in de volgorde waarin ze zijn ingevoegd. Dit maakt geordende iteratie van invoeging in een set mogelijk. Maar dit zorgt ervoor dat de klasse LinkedHashSet bewerkingen langer uitvoert dan de klasse HashSet .
Belangrijke kenmerken van LinkedHashSet
We kunnen unieke elementen alleen opslaan in een LinkedHashSet
Met LinketHashSet kunnen we elementen extraheren in dezelfde volgorde als waarin we ze invoegen
LinkedHashSet is niet gesynchroniseerd
Met LinkedHashSet kunnen null-elementen worden opgeslagen
LinkedHashSet gebruikt een hash-techniek om elementen op te slaan in een gespecificeerde index op basis van een hash-code
LinkedHashSet-methoden
Naast de methoden die zijn geërfd van de bovenliggende klassen, definieert HashSet de volgende methoden:
boolean add(Object o) voegt het opgegeven element toe aan deze set als het nog niet aanwezig is.
void clear() verwijdert alle elementen uit deze set.
Object clone() retourneert een ondiepe kopie van deze LinkedHashSet- instantie: de elementen zelf worden niet gekloond.
boolean bevat(Object o) retourneert waar als deze set het opgegeven element bevat.
boolean isEmpty() retourneert true als deze set geen elementen bevat.
Iterator iterator() retourneert een iterator over de elementen van deze set.
boolean remove(Object o) verwijdert het opgegeven element uit deze set, indien aanwezig.
int size() retourneert het aantal elementen in deze set (het aantal elementen).
Eenvoudige LinkedHashSet-voorbeeldenIn het onderstaande voorbeeld laten we de initialisatie zien van het
LinkedHashSet- object en het gebruik van de methode
add() om de set in te vullen.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx1 {
public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
set.add("Re"); //first added element
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");//last added element
System.out.println(set);
}
}
De uitvoer is:
[Re, Do, Fa, Sol, La, Ti, Mi]
Zoals je kunt zien, verschenen de elementen in onze set in dezelfde volgorde waarin we ze hadden geplaatst.
Voorbeeld 2. Een duplicaat toevoegen aan LinkedHashSet
Laten we onze LinkedHashSet 7 elementen met namen van partituren opnieuw invoeren en een nieuw element toevoegen dat hetzelfde is als een van de eerder geplaatste elementen.
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetEx2 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
set.add("Sol");
System.out.println(set);
}
}
De uitvoer van het programma is hier:
[Re, Do, Fa, Sol, La, Ti, Mi]
De uitvoer van Voorbeeld twee is precies hetzelfde als in het eerste voorbeeld. We kunnen geen twee vergelijkbare elementen in de
LinkedHashSet- collectie hebben. Wanneer we de tweede proberen te plaatsen, wordt deze gewoon genegeerd.
Voorbeeld 3. Elementen verwijderen uit LinkedHashSet
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSet3 {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("Re");
set.add("Do");
set.add("Fa");
set.add("Sol");
set.add("La");
set.add("Ti");
set.add("Mi");
System.out.println(set);
set.remove("Fa");// removing an element from our set
set.remove("Score");//trying to remove element that isn't in set
System.out.println(set.remove("Score"));
System.out.println("Print our set without elements removed: ");
System.out.println(set);
set.clear();
System.out.println("Print out our set after clear command: ");
System.out.println(set);
}
}
De uitvoer van het programma is hier:
[Re, Do, Fa, Sol, La, Ti, Mi] false Print onze set zonder verwijderde elementen: [Re, Do, Sol, La, Ti, Mi] Print onze set na duidelijk commando: []
Zoals u kunt zien, resulteert de methode
remove() toegepast op een niet-bestaand element niet in een programmafout. Het retourneert gewoon
false als het element niet is verwijderd en
true als het element in de
LinkedHashSet stond en vervolgens werd verwijderd.
LinkedHashSet versus HashSet
Deze twee klassen zijn naaste verwanten.
Binnen de HashSet gebruikt het echter
HashMap om objecten op te slaan, terwijl
LinkedHashSet LinkedHashMap gebruikt . Als u de invoegvolgorde niet hoeft te handhaven maar unieke objecten moet opslaan, is het geschikter om
HashSet te gebruiken . Als u de invoegvolgorde van elementen moet behouden, dan is
LinkedHashSet uw keuze. De prestaties van
LinkedHashSet zijn iets langzamer dan
HashSet omdat
LinkedHashSet interne
LinkedList gebruikt om de invoegvolgorde van elementen te behouden. Laten we een voorbeeld nemen:
import java.util.*;
public class LinkedHashSetExample1 {
public static void main(String[] args) {
// while regular hash set orders its elements according to its hashcode stamps
Set<Integer> regularHashSet = new HashSet<>();
regularHashSet.add(7);
regularHashSet.add(3);
regularHashSet.add(5);
regularHashSet.add(65536);
regularHashSet.add(9);
// few duplicates
regularHashSet.add(5);
regularHashSet.add(7);
// next will print:
// > regularHashSet = [65536, 3, 5, 7, 9]
System.out.println("regularHashSet = " + regularHashSet);
// linked hash set keeps order of adding unchanged
Set<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(7);
linkedHashSet.add(3);
linkedHashSet.add(5);
linkedHashSet.add(65536);
linkedHashSet.add(9);
// few duplicates
linkedHashSet.add(5);
linkedHashSet.add(7);
// next will print:
// > linkedHashSet = [7, 3, 5, 65536, 9]
System.out.println("linkedHashSet = " + linkedHashSet);
}
}
Java LinkedHashSet gebruiken in echte toepassingen
Aangezien u
met LinkedHashSet snel kunt controleren op het bestaan van een item en ook de bestelling kunt opslaan, lijkt deze verzameling erg handig om duplicaten uit een lijst te verwijderen. Of bijvoorbeeld het oplossen van problemen zoals het laatst geziene item in mijn tas. Of, herinner je je nog zo'n spel, Pokemon Go?
LinkedHashSet kan een lijst opslaan van Pokémon die je bent tegengekomen en de volgorde waarin ze op je pad zijn tegengekomen. In dit geval wordt de "herhaalde" Pokémon niet meer aan de lijst toegevoegd. Of bijvoorbeeld een lijst met bazen per level die je al hebt ontmoet in een game met levels. Of de geschiedenis van de ontdekking van kosmische lichamen.
LinkedHashSetstelt je in staat om snel te controleren of een ruimtelichaam al in de lijst staat of niet, en als het er niet is, voeg het dan toe aan de lijst. Laten we een voorbeeld nemen van het elimineren van duplicaten.
import java.util.*;
class LinkedHashSetExample2 {
public static void main(String[] args) {
List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");
Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);
// next will print:
// > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
System.out.println("listWithDuplicates = " + listWithDuplicates);
// next will print:
// > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);
// -------------------------------------------------------------------------
// while using regular Hash Set will generally produces some unexpected order
Set<String> regularHashSet = new HashSet<>(listWithDuplicates);
// next will print:
// > linkedHashSet = [some, elements, with, few, duplicates, were, here]
System.out.println("linkedHashSet = " + linkedHashSet);
// next will print:
// > regularHashSet = [here, some, with, duplicates, were, elements, few]
System.out.println("regularHashSet = " + regularHashSet);
}
}
De uitvoer van het programma is hier:
listWithDuplicates = [sommige, elementen, met, weinig, duplicaten, waren, hier, duplicaten, duplicaten] listWithoutDuplicates = [sommige, elementen, met, weinig, duplicaten, waren, hier] linkedHashSet = [sommige, elementen, met, weinig, duplicaten , waren, hier] regularHashSet = [hier, sommige, met, duplicaten, waren, elementen, weinig]
GO TO FULL VERSION