På tal om klassen LinkedHashSet i Java måste vi nämna att den implementerar Set -gränssnittet. LinkedHashSet skapar en samling som lagrar element i en hashtabell men bibehåller insättningsordningen för element till skillnad från dess HashSet -motsvarighet.

Vad är inställt i Java

Låt oss kort komma ihåg att Set -gränssnittet definierar en uppsättning (uppsättning). Den utökar samlingen och definierar beteendet för samlingar som inte tillåter dubbletter av element. Således returnerar add() -metoden false om ett försök görs att lägga till ett duplikatelement till uppsättningen. Gränssnittet definierar inga egna ytterligare metoder. Set - gränssnittet tar hand om unikheten hos lagrade objekt, unikhet bestäms av implementeringen av equals()- metoden. Därför, om objekt av den skapade klassen kommer att läggas till i Set , är det önskvärt att åsidosätta equals()- metoden.

LinkedHashSet-klass

Innan vi pratar om LinkedHashSet- klassen måste vi nämna dess nära släkting, HashSet -klassen. HashSet implementerar Set- gränssnittet. Det skapar en samling som lagrar elementen i en hashtabell. Elementen i en hashtabell lagras som nyckel-värdepar. Nyckeln anger cellen (eller segmentet) för att lagra värdet. Innehållet i nyckeln används för att bestämma ett unikt värde som kallas en hashkod. Vi kan tänka på en hash-kod som en objektidentifierare, även om den inte behöver vara unik. Denna hash-kod fungerar också som ett index till vilket data som är associerade med nyckeln lagras. LinkedHashSet Java - klassen utökar HashSet utan att lägga till några nya metoder.LinkedHashSet låter dig snabbt kontrollera om det finns en post, precis som HashSet , men innehåller en ordnad lista inuti. Det betyder att den lagrar insättningsordningen för elementen. Med andra ord upprätthåller LinkedHashSet en länkad lista med setelement i den ordning de infogades. Detta tillåter ordnad iteration av infogning i en uppsättning. Men detta gör att klassen LinkedHashSet utför operationer längre än klassen HashSet .

Viktiga funktioner i LinkedHashSet

  • Vi kan endast lagra unika element i ett LinkedHashSet

  • LinketHashSet låter oss extrahera element i samma ordning som vi infogar

  • LinkedHashSet är inte synkroniserat

  • LinkedHashSet tillåter lagring av null-element

  • LinkedHashSet använder en hashteknik för att lagra element vid ett specificerat index baserat på en hashkod

LinkedHashSet-metoder

Förutom metoderna som ärvts från dess överordnade klasser, definierar HashSet följande metoder:

  • boolean add(Object o) lägger till det angivna elementet till denna uppsättning om det inte redan finns.

  • void clear() tar bort alla element från denna uppsättning.

  • Object clone() returnerar en ytlig kopia av denna LinkedHashSet- instans: själva elementen klonas inte.

  • boolean innehåller(Objekt o) returnerar sant om denna uppsättning innehåller det angivna elementet.

  • boolean isEmpty() returnerar true om denna uppsättning inte innehåller några element.

  • Iterator iterator() returnerar en iterator över elementen i denna uppsättning.

  • boolean remove(Object o) tar bort det angivna elementet från denna uppsättning, om det finns.

  • int size() returnerar antalet element i denna uppsättning (dess antal element).

Easy LinkedHashSet-exempelI exemplet nedan visar vi initiering av LinkedHashSet- objektet och använder add()- metoden för att fylla i setet. 

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);
       }
   }
Utgången är:
[Re, Do, Fa, Sol, La, Ti, Mi]
Som du kan se dök elementen i vår uppsättning upp i samma ordning som vi placerade dem i. LinkedHashSet i Java - 1

Exempel 2. Lägga till en dubblett i LinkedHashSet

Låt oss lägga in våra LinkedHashSet 7 element med namn på musikmusik igen och sätta in ett nytt element som är detsamma som ett av elementen placerade tidigare. 

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 är här:
[Re, Do, Fa, Sol, La, Ti, Mi]
Utdata från exempel två är exakt densamma som i det första exemplet. Vi kan inte ha två liknande element i LinkedHashSet -samlingen. När vi försöker lägga den andra ignoreras den bara.

Exempel 3. Ta bort element från 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 är här:
[Re, Do, Fa, Sol, La, Ti, Mi] false Skriv ut vårt set utan element borttagna: [Re, Do, Sol, La, Ti, Mi] Skriv ut vårt set efter ett tydligt kommando: []
Som du kan se resulterar inte metoden remove() som tillämpas på ett icke-existerande element i ett programfel. Det returnerar helt enkelt falskt om elementet inte togs bort och sant om elementet fanns i LinkedHashSet och sedan togs bort.

LinkedHashSet vs HashSet

Dessa två klasser är nära släktingar. Men inne i HashSet använder den HashMap för att lagra objekt medan LinkedHashSet använder LinkedHashMap . Om du inte behöver upprätthålla insättningsordningen utan behöver lagra unika objekt är det mer lämpligt att använda HashSet . Om du behöver bibehålla insättningsordningen för element är LinkedHashSet ditt val. Prestanda för LinkedHashSet är lite långsammare än HashSet eftersom LinkedHashSet använder intern LinkedList för att bibehålla insättningsordningen för element. Låt oss ta ett exempel: 

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 av programmet är:
regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

Använder Java LinkedHashSet i verkliga applikationer

Eftersom LinkedHashSet låter dig snabbt kontrollera om det finns en post och även lagrar beställning, verkar denna samling vara ganska bekväm för att eliminera dubbletter från en lista. Eller till exempel att lösa problem som det senast sett i min väska. Eller minns du ett sådant spel, Pokemon Go? LinkedHashSet kan lagra en lista över Pokémon du har stött på och i vilken ordning de stötte på din väg. I det här fallet kommer den "upprepade" Pokémon inte längre att läggas till i listan. Eller, till exempel, en lista över chefer efter nivå som du redan har träffat i något spel med nivåer. Eller historien om upptäckten av kosmiska kroppar. LinkedHashSetlåter dig snabbt kontrollera om ett mellanslag redan finns i listan eller inte, och om det inte finns där lägger du till det i listan. Låt oss ta ett exempel på att eliminera dubbletter. 

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 är här:
listWithDuplicates = [några, element, med, få, dubbletter, var, här, dubbletter, dubbletter] listWithoutDuplicates = [några, element, med, få, dubbletter, var, här] linkedHashSet = [några, element, med, få, dubbletter , were, here] regularHashSet = [här, några, med, dubbletter, var, element, få]