Sa pagsasalita tungkol sa klase ng LinkedHashSet sa Java, kailangan nating banggitin na ipinapatupad nito ang Set interface. Lumilikha ang LinkedHashSet ng isang koleksyon na nag-iimbak ng mga elemento sa isang hash table ngunit pinapanatili ang pagkakasunud-sunod ng pagpapasok ng mga elemento hindi katulad ng katapat nitong HashSet .

Ano ang Nakatakda sa Java

Panandalian nating alalahanin na ang Set interface ay tumutukoy sa isang set (set). Pinapalawak nito ang Koleksyon at tinutukoy ang gawi ng mga koleksyon na hindi nagpapahintulot ng mga duplicate na elemento. Kaya, ang paraan ng add() ay nagbabalik ng false kung ang isang pagtatangka ay ginawa upang magdagdag ng isang duplicate na elemento sa set. Ang interface ay hindi tumutukoy sa anumang karagdagang mga pamamaraan ng sarili nitong. Ang interface ng Set ay nangangalaga sa pagiging natatangi ng mga nakaimbak na bagay, ang pagiging natatangi ay tinutukoy ng pagpapatupad ng equals() na pamamaraan. Samakatuwid, kung ang mga bagay ng nilikhang klase ay idaragdag sa Set , ito ay kanais-nais na i-override ang equals() na pamamaraan.

LinkedHashSet klase

Bago pag-usapan ang LinkedHashSet class, kailangan nating banggitin ang malapit na kamag-anak nito, ang HashSet class. Ang HashSet ay nagpapatupad ng Set interface. Lumilikha ito ng isang koleksyon na nag-iimbak ng mga elemento sa isang hash table. Ang mga elemento ng hash table ay iniimbak bilang key-value pairs. Tinukoy ng key ang cell (o segment) upang mag-imbak ng halaga. Ang nilalaman ng susi ay ginagamit upang matukoy ang isang natatanging halaga na tinatawag na hash code. Maaari naming isipin ang isang hash code bilang isang object identifier, bagama't hindi ito kailangang maging kakaiba. Ang hash code na ito ay nagsisilbi rin bilang isang index kung saan iniimbak ang data na nauugnay sa key. Ang LinkedHashSet Java class ay nagpapalawak ng HashSet nang hindi nagdaragdag ng anumang mga bagong pamamaraan.Binibigyang-daan ka ng LinkedHashSet na mabilis na suriin ang pagkakaroon ng isang entry, tulad ng HashSet , ngunit naglalaman ng nakaayos na listahan sa loob. Nangangahulugan ito na iniimbak nito ang pagkakasunud-sunod ng pagpapasok ng mga elemento. Sa madaling salita, ang LinkedHashSet ay nagpapanatili ng isang naka-link na listahan ng mga set na elemento sa pagkakasunud-sunod ng mga ito ay ipinasok. Nagbibigay-daan ito sa nakaayos na pag-ulit ng pagpapasok sa isang set. Ngunit nagiging sanhi ito ng LinkedHashSet class na magsagawa ng mga operasyon nang mas matagal kaysa sa HashSet class.

Mahahalagang Tampok ng LinkedHashSet

  • Maaari lamang kaming mag-imbak ng mga natatanging elemento sa isang LinkedHashSet

  • LinketHashSet hayaan kaming mag-extract ng mga elemento sa parehong pagkakasunud-sunod na ipinapasok namin

  • Ang LinkedHashSet ay Hindi Naka-synchronize

  • Pinapayagan ng LinkedHashSet ang pag-iimbak ng mga null na elemento

  • Gumagamit ang LinkedHashSet ng pamamaraan ng hashing upang mag-imbak ng mga elemento sa isang tinukoy na index batay sa isang hash code

Mga Paraan ng LinkedHashSet

Bilang karagdagan sa mga pamamaraan na minana mula sa mga pangunahing klase nito, tinukoy ng HashSet ang mga sumusunod na pamamaraan:

  • idinaragdag ng boolean add(Object o) ang tinukoy na elemento sa set na ito kung wala pa ito.

  • inaalis ng void clear() ang lahat ng elemento mula sa set na ito.

  • Ang Object clone() ay nagbabalik ng mababaw na kopya ng LinkedHashSet instance na ito: ang mga elemento mismo ay hindi naka-clone.

  • Ang boolean contains(Object o) ay nagbabalik ng true kung ang set na ito ay naglalaman ng tinukoy na elemento.

  • Ang boolean isEmpty() ay nagbabalik ng true kung ang set na ito ay walang mga elemento.

  • Ang iterator iterator() ay nagbabalik ng iterator sa mga elemento ng set na ito.

  • Tinatanggal ng boolean remove(Object o) ang tinukoy na elemento mula sa set na ito, kung mayroon.

  • int size() ay nagbabalik ng bilang ng mga elemento sa set na ito (ang bilang ng mga elemento nito).

Mga halimbawa ng Easy LinkedHashSetSa halimbawa sa ibaba ipinapakita namin ang pagsisimula ng object ng LinkedHashSet at gamit ang paraan ng add() upang punan ang set. 

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);
       }
   }
Ang output ay:
[Re, Do, Fa, Sol, La, Ti, Mi]
Tulad ng nakikita mo, ang mga elemento sa aming set ay lumitaw sa parehong pagkakasunud-sunod kung saan namin inilagay ang mga ito. LinkedHashSet sa Java - 1

Halimbawa 2. Pagdaragdag ng duplicate sa LinkedHashSet

Ilagay natin muli ang ating LinkedHashSet 7 elemento na may mga pangalan ng mga musical score at maglagay ng isang bagong elemento na kapareho ng isa sa mga elementong inilagay dati. 

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);
       }
   }
Ang output ng programa ay narito:
[Re, Do, Fa, Sol, La, Ti, Mi]
Ang output ng Halimbawa ng dalawa ay eksaktong kapareho ng sa unang halimbawa. Hindi tayo maaaring magkaroon ng dalawang magkatulad na elemento sa koleksyon ng LinkedHashSet . Kapag sinubukan naming ilagay ang pangalawa, ito ay hindi pinansin.

Halimbawa 3. Pag-alis ng mga elemento mula sa 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);
       }
   }
Ang output ng programa ay narito:
[Re, Do, Fa, Sol, La, Ti, Mi] false I-print ang aming set nang walang mga elementong inalis: [Re, Do, Sol, La, Ti, Mi] I-print ang aming set pagkatapos ng malinaw na utos: []
Tulad ng nakikita mo, ang paraan ng remove() na inilapat sa isang hindi umiiral na elemento ay hindi nagreresulta sa isang error sa programa. Nagbabalik lang ito ng false kung hindi inalis ang elemento at true kung nasa LinkedHashSet ang elemento at pagkatapos ay inalis.

LinkedHashSet kumpara sa HashSet

Ang dalawang klase na ito ay malapit na magkamag-anak. Gayunpaman sa loob ng HashSet ito ay gumagamit ng HashMap upang mag-imbak ng mga bagay habang ang LinkedHashSet ay gumagamit ng LinkedHashMap . Kung hindi mo kailangang mapanatili ang pagkakasunud-sunod ng pagpapasok ngunit kailangan mong mag-imbak ng mga natatanging bagay, mas angkop na gamitin ang HashSet . Kung kailangan mong mapanatili ang pagkakasunud-sunod ng pagpapasok ng mga elemento, ang LinkHashSet ang iyong pipiliin. Ang pagganap ng LinkedHashSet ay medyo mas mabagal kaysa sa HashSet dahil ang LinkedHashSet ay gumagamit ng panloob na LinkedList upang mapanatili ang pagkakasunud-sunod ng pagpapasok ng mga elemento. Magkaroon tayo ng isang halimbawa: 

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);
   }
}
Ang output ng programa ay:
regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

Paggamit ng Java LinkedHashSet sa mga totoong application sa mundo

Dahil pinapayagan ka ng LinkedHashSet na mabilis na suriin ang pagkakaroon ng isang entry at mag-imbak din ng order, ang koleksyon na ito ay tila medyo maginhawa para sa pag-aalis ng mga duplicate mula sa isang listahan. O, halimbawa, paglutas ng mga problema tulad ng huling nakitang item sa aking bag. O, tandaan ang gayong laro, Pokemon Go? Maaaring mag-imbak ang LinkedHashSet ng isang listahan ng Pokémon na iyong nakatagpo at ang pagkakasunud-sunod kung saan sila napunta sa iyong landas. Sa kasong ito, ang "paulit-ulit" na Pokémon ay hindi na idaragdag sa listahan. O, halimbawa, isang listahan ng mga boss ayon sa antas na nakilala mo na sa anumang laro na may mga antas. O ang kasaysayan ng pagtuklas ng mga cosmic na katawan. LinkedHashSetnagbibigay-daan sa iyong mabilis na suriin kung ang isang space body ay nasa listahan na o wala, at kung wala ito, pagkatapos ay idagdag ito sa listahan. Kumuha tayo ng isang halimbawa ng pag-aalis ng mga duplicate. 

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);
   }
}
Ang output ng programa ay narito:
listWithDuplicates = [some, elements, with, few, duplicates, were, here, duplicates, duplicates] listWithoutDuplicates = [some, elements, with, few, duplicates, were, here] linkedHashSet = [some, elements, with, few, duplicates , were, here] regularHashSet = [dito, ilan, may, duplicate, ay, elemento, iilan]