Når vi snakker om LinkedHashSet- klassen i Java, må vi nevne at den implementerer Set- grensesnittet. LinkedHashSet oppretter en samling som lagrer elementer i en hash-tabell, men opprettholder innsettingsrekkefølgen til elementer i motsetning til HashSet -motparten.
Hva er satt i Java
La oss kort huske at Set- grensesnittet definerer et sett (sett). Den utvider samlingen og definerer oppførselen til samlinger som ikke tillater dupliserte elementer. Dermed returnerer add() -metoden usann hvis det gjøres et forsøk på å legge til et duplikatelement til settet. Grensesnittet definerer ingen egne ekstra metoder. Set - grensesnittet tar seg av det unike til lagrede objekter, unikhet bestemmes av implementeringen av equals() -metoden. Derfor, hvis objekter av den opprettede klassen vil bli lagt til settet , er det ønskelig å overstyre equals()- metoden.
LinkedHashSet-klassen
Før vi snakker om LinkedHashSet- klassen, må vi nevne dens nære slektning, HashSet -klassen. HashSet implementerer Set- grensesnittet. Den lager en samling som lagrer elementene i en hash-tabell. Elementene i en hashtabell lagres som nøkkelverdi-par. Nøkkelen spesifiserer cellen (eller segmentet) for å lagre verdien. Innholdet i nøkkelen brukes til å bestemme en unik verdi kalt en hash-kode. Vi kan tenke på en hash-kode som en objektidentifikator, selv om den ikke trenger å være unik. Denne hash-koden fungerer også som en indeks som dataene knyttet til nøkkelen er lagret til. LinkedHashSet Java-klassen utvider HashSet uten å legge til noen nye metoder.LinkedHashSet lar deg raskt sjekke om det finnes en oppføring, akkurat som HashSet , men inneholder en ordnet liste inni. Dette betyr at den lagrer innsettingsrekkefølgen til elementene. Med andre ord opprettholder LinkedHashSet en koblet liste over settelementer i den rekkefølgen de ble satt inn. Dette tillater ordnet iterasjon av innsetting i et sett. Men dette får LinkedHashSet- klassen til å utføre operasjoner lenger enn HashSet- klassen.
Viktige funksjoner i LinkedHashSet
Vi kan bare lagre unike elementer i et LinkedHashSet
LinketHashSet lar oss trekke ut elementer i samme rekkefølge som vi setter inn
LinkedHashSet er ikke synkronisert
LinkedHashSet tillater lagring av null-elementer
LinkedHashSet bruker en hash-teknikk for å lagre elementer i en spesifisert indeks basert på en hash-kode
LinkedHashSet-metoder
I tillegg til metodene som er arvet fra overordnede klasser, definerer HashSet følgende metoder:
boolean add(Object o) legger til det spesifiserte elementet til dette settet hvis det ikke allerede er til stede.
void clear() fjerner alle elementer fra dette settet.
Object clone() returnerer en grunn kopi av denne LinkedHashSet- forekomsten: selve elementene er ikke klonet.
boolean contains(Object o) returnerer true hvis dette settet inneholder det spesifiserte elementet.
boolean isEmpty() returnerer true hvis dette settet ikke inneholder noen elementer.
Iterator iterator() returnerer en iterator over elementene i dette settet.
boolean remove(Object o) fjerner det spesifiserte elementet fra dette settet, hvis det finnes.
int size() returnerer antall elementer i dette settet (dets antall elementer).
Easy LinkedHashSet-eksemplerI eksemplet nedenfor viser vi initialisering av
LinkedHashSet- objektet og bruk av
add()- metoden for å fylle ut settet.
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);
}
}
Utgangen er:
[Re, Do, Fa, Sol, La, Ti, Mi]
Som du kan se, dukket elementene i settet vårt opp i samme rekkefølge som vi plasserte dem i.
Eksempel 2. Legge til et duplikat i LinkedHashSet
La oss sette inn våre
LinkedHashSet 7-elementer med navn på partitur igjen og sette inn ett nytt element som er det samme som et av elementene plassert 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 av programmet er her:
[Re, Do, Fa, Sol, La, Ti, Mi]
Resultatet fra eksempel to er nøyaktig det samme som i det første eksemplet. Vi kan ikke ha to lignende elementer i
LinkedHashSet- samlingen. Når vi prøver å sette den andre, blir den bare ignorert.
Eksempel 3. Fjerning av 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 av programmet er her:
[Re, Do, Fa, Sol, La, Ti, Mi] false Skriv ut settet vårt uten elementer fjernet: [Re, Do, Sol, La, Ti, Mi] Skriv ut settet vårt etter klar kommando: []
Som du kan se, resulterer ikke
remove() -metoden som brukes på et ikke-eksisterende element i en programfeil. Det returnerer ganske enkelt
usann hvis elementet ikke ble fjernet og
sant hvis elementet var i
LinkedHashSet og deretter fjernet.
LinkedHashSet vs HashSet
Disse to klassene er nære slektninger. Men inne i
HashSet bruker den
HashMap til å lagre objekter mens
LinkedHashSet bruker
LinkedHashMap . Hvis du ikke trenger å opprettholde innsettingsrekkefølgen, men trenger å lagre unike objekter, er det mer hensiktsmessig å bruke
HashSet . Hvis du trenger å opprettholde innsettingsrekkefølgen til elementer, er
LinkedHashSet ditt valg. Ytelsen til
LinkedHashSet er litt tregere enn
HashSet fordi
LinkedHashSet bruker intern
LinkedList for å opprettholde innsettingsrekkefølgen til elementer. La oss ta 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);
}
}
Bruke Java LinkedHashSet i virkelige applikasjoner
Siden
LinkedHashSet lar deg raskt sjekke om det finnes en oppføring og også lagrer ordre, ser denne samlingen ut til å være ganske praktisk for å eliminere duplikater fra en liste. Eller for eksempel å løse problemer som den siste varen jeg har sett i vesken min. Eller husker du et slikt spill, Pokemon Go?
LinkedHashSet kan lagre en liste over Pokémon du har møtt og rekkefølgen de kom over på veien din. I dette tilfellet vil den "gjentatte" Pokémon ikke lenger legges til i listen. Eller for eksempel en liste over sjefer etter nivå som du allerede har møtt i et hvilket som helst spill med nivåer. Eller historien om oppdagelsen av kosmiske kropper.
LinkedHashSetlar deg raskt sjekke om et romlegeme allerede er på listen eller ikke, og hvis det ikke er der, kan du legge det til i listen. La oss ta et eksempel på å eliminere duplikater.
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 av programmet er her:
listWithDuplicates = [noen, elementer, med, få, duplikater, var, her, duplikater, duplikater] listWithoutDuplicates = [noen, elementer, med, få, duplikater, var, her] linkedHashSet = [noen, elementer, med, få, duplikater , var, her] regularHashSet = [her, noen, med, duplikater, var, elementer, få]
GO TO FULL VERSION