LinkedHashSet i Java

Når vi taler om LinkedHashSet- klassen i Java, skal vi nævne, at den implementerer Set- grænsefladen. LinkedHashSet opretter en samling, der gemmer elementer i en hash-tabel, men opretholder indsættelsesrækkefølgen af elementer i modsætning til dens HashSet- modstykke.

Hvad er indstillet i Java

Lad os kort huske, at sæt- grænsefladen definerer et sæt (sæt). Det udvider Collection og definerer adfærden for samlinger, der ikke tillader duplikerede elementer. Således returnerer add() metoden false , hvis der gøres et forsøg på at tilføje et dubletelement til sættet. Grænsefladen definerer ikke sine egne yderligere metoder. Set - grænsefladen tager sig af det unikke ved lagrede objekter, unikhed bestemmes af implementeringen af equals()- metoden. Derfor, hvis objekter af den oprettede klasse vil blive tilføjet til sættet , er det ønskeligt at tilsidesætte equals()- metoden.

LinkedHashSet klasse

Før vi taler om LinkedHashSet- klassen, skal vi nævne dens nære slægtning, HashSet- klassen. HashSet implementerer Set- grænsefladen. Det opretter en samling, der gemmer elementerne i en hash-tabel. Elementerne i en hash-tabel gemmes som nøgleværdi-par. Nøglen angiver cellen (eller segmentet), der skal gemme værdien. Indholdet af nøglen bruges til at bestemme en unik værdi kaldet en hash-kode. Vi kan tænke på en hash-kode som en objektidentifikator, selvom den ikke behøver at være unik. Denne hash-kode fungerer også som et indeks, hvortil de data, der er knyttet til nøglen, gemmes. LinkedHashSet Java-klassen udvider HashSet uden at tilføje nye metoder.LinkedHashSet giver dig mulighed for hurtigt at kontrollere eksistensen af en post, ligesom HashSet , men indeholder en ordnet liste indeni. Det betyder, at den gemmer elementernes indsættelsesrækkefølge. Med andre ord vedligeholder LinkedHashSet en sammenkædet liste over sæt-elementer i den rækkefølge, de blev indsat. Dette tillader ordnet iteration af indsættelse i et sæt. Men dette får LinkedHashSet- klassen til at udføre operationer længere end HashSet- klassen.

Vigtige funktioner i LinkedHashSet

Vi kan kun gemme unikke elementer i et LinkedHashSet
LinketHashSet lader os udtrække elementer i samme rækkefølge, som vi indsætter
LinkedHashSet er ikke synkroniseret
LinkedHashSet tillader lagring af null-elementer
LinkedHashSet bruger en hash-teknik til at gemme elementer ved et specificeret indeks baseret på en hash-kode

LinkedHashSet-metoder

Ud over de metoder, der er arvet fra dets overordnede klasser, definerer HashSet følgende metoder:

boolean add(Object o) tilføjer det angivne element til dette sæt, hvis det ikke allerede er til stede.
void clear() fjerner alle elementer fra dette sæt.
Object clone() returnerer en overfladisk kopi af denne LinkedHashSet- instans: selve elementerne klones ikke.
boolean contains(Object o) returnerer sand, hvis dette sæt indeholder det angivne element.
boolean isEmpty() returnerer sand , hvis dette sæt ikke indeholder nogen elementer.
Iterator iterator() returnerer en iterator over elementerne i dette sæt.
boolean remove(Object o) fjerner det angivne element fra dette sæt, hvis det findes.
int size() returnerer antallet af elementer i dette sæt (dets antal elementer).

Easy LinkedHashSet-eksemplerI eksemplet nedenfor viser vi initialisering af LinkedHashSet- objektet og brug af add()- metoden til at udfylde sættet.

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);
       }
   }

Udgangen er:

[Re, Do, Fa, Sol, La, Ti, Mi]

Som du kan se, dukkede elementerne i vores sæt op i samme rækkefølge, som vi placerede dem i.

Eksempel 2. Tilføjelse af en dublet i LinkedHashSet

Lad os indsætte vores LinkedHashSet 7 elementer med navne på noder igen og sætte et nyt element, der er det samme som et af elementerne placeret før.

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);
       }
   }

Resultatet af programmet er her:

[Re, Do, Fa, Sol, La, Ti, Mi]

Outputtet fra eksempel to er nøjagtigt det samme som i det første eksempel. Vi kan ikke have to lignende elementer i LinkedHashSet- samlingen. Når vi prøver at sætte den anden, bliver den bare ignoreret.

Eksempel 3. Fjernelse af elementer fra 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);
       }
   }

Resultatet af programmet er her:

[Re, Do, Fa, Sol, La, Ti, Mi] false Udskriv vores sæt uden elementer fjernet: [Re, Do, Sol, La, Ti, Mi] Udskriv vores sæt efter klar kommando: []

Som du kan se, resulterer remove()- metoden anvendt på et ikke-eksisterende element ikke i en programfejl. Det returnerer simpelthen falsk , hvis elementet ikke blev fjernet, og sandt , hvis elementet var i LinkedHashSet og derefter fjernet.

LinkedHashSet vs HashSet

Disse to klasser er nære slægtninge. Men inde i HashSet bruger den HashMap til at gemme objekter, mens LinkedHashSet bruger LinkedHashMap . Hvis du ikke har brug for at vedligeholde indsættelsesrækkefølgen, men skal gemme unikke objekter, er det mere hensigtsmæssigt at bruge HashSet . Hvis du har brug for at opretholde indsættelsesrækkefølgen af elementer, er LinkedHashSet dit valg. Ydeevnen af LinkedHashSet er en smule langsommere end HashSet , fordi LinkedHashSet bruger intern LinkedList til at opretholde indsættelsesrækkefølgen af elementer. Lad os få et eksempel:

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);
   }
}

Resultatet af programmet er:

regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

Brug af Java LinkedHashSet i applikationer fra den virkelige verden

Da LinkedHashSet giver dig mulighed for hurtigt at kontrollere eksistensen af en post og også gemmer ordre, ser denne samling ud til at være ret praktisk til at fjerne dubletter fra en liste. Eller for eksempel at løse problemer som det sidst sete element i min taske. Eller husker du sådan et spil, Pokemon Go? LinkedHashSet kan gemme en liste over Pokémon, du har stødt på, og den rækkefølge, de stødte på på din vej. I dette tilfælde vil den "gentagne" Pokémon ikke længere blive tilføjet til listen. Eller for eksempel en liste over chefer efter niveau, som du allerede har mødt i ethvert spil med niveauer. Eller historien om opdagelsen af kosmiske legemer. LinkedHashSetgiver dig mulighed for hurtigt at kontrollere, om et rumlegeme allerede er på listen eller ej, og hvis det ikke er der, så føje det til listen. Lad os tage et eksempel på at fjerne dubletter.

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);
   }
}

Resultatet af programmet er her:

listWithDuplicates = [nogle, elementer, med, få, dubletter, var, her, dubletter, dubletter] listWithoutDuplicates = [nogle, elementer, med, få, dubletter, var, her] linkedHashSet = [nogle, elementer, med, få, dubletter , were, here] regularHashSet = [her, nogle, med, dubletter, var, elementer, få]