కోడ్‌జిమ్/జావా బ్లాగ్/యాదృచ్ఛికంగా/జావాలో లింక్డ్‌హాష్‌సెట్
John Squirrels
స్థాయి
San Francisco

జావాలో లింక్డ్‌హాష్‌సెట్

సమూహంలో ప్రచురించబడింది
జావాలోని లింక్డ్‌హాష్‌సెట్ క్లాస్ గురించి మాట్లాడుతూ , ఇది సెట్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుందని మనం పేర్కొనాలి . LinkedHashSet ఒక హాష్ పట్టికలో మూలకాలను నిల్వ చేసే సేకరణను సృష్టిస్తుంది కానీ దాని HashSet ప్రతిరూపం వలె కాకుండా మూలకాల యొక్క చొప్పించే క్రమాన్ని నిర్వహిస్తుంది.

జావాలో ఏమి సెట్ చేయబడింది

సెట్ ఇంటర్‌ఫేస్ సమితిని (సెట్) నిర్వచించిందని క్లుప్తంగా గుర్తుచేసుకుందాం . ఇది సేకరణను పొడిగిస్తుంది మరియు నకిలీ మూలకాలను అనుమతించని సేకరణల ప్రవర్తనను నిర్వచిస్తుంది. కాబట్టి, సెట్‌కు నకిలీ మూలకాన్ని జోడించడానికి ప్రయత్నించినట్లయితే add() పద్ధతి తప్పుగా చూపబడుతుంది . ఇంటర్ఫేస్ దాని స్వంత అదనపు పద్ధతులను నిర్వచించదు. సెట్ ఇంటర్‌ఫేస్ నిల్వ చేయబడిన వస్తువుల ప్రత్యేకతను జాగ్రత్తగా చూసుకుంటుంది, సమాన () పద్ధతిని అమలు చేయడం ద్వారా ప్రత్యేకత నిర్ణయించబడుతుంది . కాబట్టి, సృష్టించబడిన తరగతికి చెందిన వస్తువులు సెట్‌కి జోడించబడితే , సమానం() పద్ధతిని భర్తీ చేయడం మంచిది .

లింక్డ్‌హాష్‌సెట్ క్లాస్

లింక్డ్‌హాష్‌సెట్ క్లాస్ గురించి మాట్లాడే ముందు , మనం దాని దగ్గరి బంధువైన హాష్‌సెట్ క్లాస్ గురించి ప్రస్తావించాలి . HashSet సెట్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది . ఇది హాష్ పట్టికలో మూలకాలను నిల్వ చేసే సేకరణను సృష్టిస్తుంది. హాష్ పట్టిక యొక్క మూలకాలు కీ-విలువ జంటలుగా నిల్వ చేయబడతాయి. విలువను నిల్వ చేయడానికి కీ సెల్ (లేదా సెగ్మెంట్)ను నిర్దేశిస్తుంది. హాష్ కోడ్ అని పిలువబడే ప్రత్యేక విలువను గుర్తించడానికి కీ యొక్క కంటెంట్ ఉపయోగించబడుతుంది. మేము హాష్ కోడ్‌ని ఆబ్జెక్ట్ ఐడెంటిఫైయర్‌గా భావించవచ్చు, అయినప్పటికీ ఇది ప్రత్యేకంగా ఉండవలసిన అవసరం లేదు. ఈ హాష్ కోడ్ కీతో అనుబంధించబడిన డేటా నిల్వ చేయబడే సూచికగా కూడా పనిచేస్తుంది. లింక్డ్‌హాష్‌సెట్ జావా క్లాస్ ఏ కొత్త పద్ధతులను జోడించకుండానే హాష్‌సెట్‌ను పొడిగిస్తుంది.లింక్డ్‌హాష్‌సెట్ హ్యాష్‌సెట్ లాగానే ఎంట్రీ ఉనికిని త్వరగా తనిఖీ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది , కానీ లోపల ఆర్డర్ చేసిన జాబితాను కలిగి ఉంటుంది. ఇది మూలకాల యొక్క చొప్పించే క్రమాన్ని నిల్వ చేస్తుందని అర్థం. మరో మాటలో చెప్పాలంటే, లింక్డ్‌హాష్‌సెట్ వారు చొప్పించిన క్రమంలో సెట్ మూలకాల యొక్క లింక్డ్ జాబితాను నిర్వహిస్తుంది. ఇది సెట్‌లోకి చొప్పించడం యొక్క ఆర్డర్‌ని పునరావృతం చేయడానికి అనుమతిస్తుంది. కానీ దీని వలన LinkedHashSet క్లాస్ HashSet క్లాస్ కంటే ఎక్కువసేపు కార్యకలాపాలు నిర్వహించేలా చేస్తుంది .

LinkedHashSet యొక్క ముఖ్యమైన లక్షణాలు

  • మేము ఏకైక అంశాలను లింక్డ్‌హాష్‌సెట్‌లో మాత్రమే నిల్వ చేయగలము

  • LinketHashSet మనం చొప్పించే అదే క్రమంలో మూలకాలను సంగ్రహించడానికి అనుమతిస్తుంది

  • LinkedHashSet సమకాలీకరించబడలేదు

  • LinkedHashSet శూన్య అంశాలను నిల్వ చేయడానికి అనుమతిస్తుంది

  • లింక్డ్‌హాష్‌సెట్ హాష్ కోడ్ ఆధారంగా పేర్కొన్న సూచికలో మూలకాలను నిల్వ చేయడానికి హ్యాషింగ్ టెక్నిక్‌ను ఉపయోగిస్తుంది

లింక్డ్‌హాష్‌సెట్ పద్ధతులు

దాని మాతృ తరగతుల నుండి వారసత్వంగా పొందిన పద్ధతులతో పాటు, HashSet క్రింది పద్ధతులను నిర్వచిస్తుంది:
  • boolean add(Object o) ఈ సెట్‌కు పేర్కొన్న మూలకం ఇప్పటికే లేకుంటే దానికి జోడిస్తుంది.

  • void clear() ఈ సెట్ నుండి అన్ని మూలకాలను తొలగిస్తుంది.

  • ఆబ్జెక్ట్ క్లోన్() ఈ లింక్డ్‌హాష్‌సెట్ ఉదాహరణ యొక్క నిస్సార కాపీని అందిస్తుంది : మూలకాలు స్వయంగా క్లోన్ చేయబడవు.

  • ఈ సెట్ పేర్కొన్న మూలకాన్ని కలిగి ఉన్నట్లయితే boolean కలిగి(Object o) నిజాన్ని అందిస్తుంది.

  • ఈ సెట్‌లో మూలకాలు ఏవీ లేనట్లయితే boolean isEmpty() నిజమని చూపుతుంది .

  • ఇటరేటర్ ఇటరేటర్() ఈ సెట్ యొక్క మూలకాలపై ఒక ఇటరేటర్‌ని అందిస్తుంది.

  • boolean remove(Object o) ఈ సెట్ నుండి పేర్కొన్న ఎలిమెంట్‌ని తొలగిస్తుంది.

  • int size() ఈ సెట్‌లోని మూలకాల సంఖ్యను అందిస్తుంది (దాని మూలకాల సంఖ్య).

సులభమైన లింక్డ్‌హాష్‌సెట్ ఉదాహరణలు దిగువ ఉదాహరణలో మేము లింక్డ్‌హాష్‌సెట్ ఆబ్జెక్ట్ యొక్క ప్రారంభాన్ని చూపుతాము మరియు సెట్‌లో పూరించడానికి add() పద్ధతిని ఉపయోగిస్తాము.
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);
       }
   }
అవుట్‌పుట్:
[Re, Do, Fa, Sol, La, Ti, Mi]
మీరు చూడగలిగినట్లుగా, మా సెట్‌లోని అంశాలు మేము వాటిని ఉంచిన క్రమంలోనే కనిపించాయి. జావాలో లింక్డ్‌హాష్‌సెట్ - 1

ఉదాహరణ 2. LinkedHashSetకి నకిలీని జోడించడం

మ్యూజికల్ స్కోర్‌ల పేర్లతో మా LinkedHashSet 7 ఎలిమెంట్‌లను మళ్లీ ఉంచుదాం మరియు ఇంతకు ముందు ఉంచిన ఎలిమెంట్‌ల మాదిరిగానే ఒక కొత్త ఎలిమెంట్‌ను ఉంచుదాం.
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);
       }
   }
ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:
[Re, Do, Fa, Sol, La, Ti, Mi]
ఉదాహరణ రెండు యొక్క అవుట్‌పుట్ మొదటి ఉదాహరణలో వలెనే ఉంటుంది. మేము LinkedHashSet సేకరణలో రెండు సారూప్య అంశాలను కలిగి ఉండలేము . మేము రెండవదాన్ని ఉంచడానికి ప్రయత్నించినప్పుడు, అది విస్మరించబడుతుంది.

ఉదాహరణ 3. 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);
       }
   }
ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:
[Re, Do, Fa, Sol, La, Ti, Mi] తప్పుడు మూలకాలు తీసివేయకుండా మా సెట్‌ని ప్రింట్ చేయండి: [Re, Do, Sol, La, Ti, Mi] స్పష్టమైన ఆదేశం తర్వాత మా సెట్‌ని ప్రింట్ చేయండి: []
మీరు చూడగలిగినట్లుగా, ఉనికిలో లేని మూలకానికి వర్తింపజేసిన తొలగించు() పద్ధతి ప్రోగ్రామ్ దోషానికి దారితీయదు. మూలకం తీసివేయబడకపోతే అది తప్పుగా మరియు లింక్డ్‌హాష్‌సెట్‌లో మూలకం ఉండి , ఆపై తీసివేయబడితే అది నిజం అని చూపుతుంది.

LinkedHashSet vs HashSet

ఈ రెండు వర్గాలు దగ్గరి బంధువులు. అయితే HashSet లోపల వస్తువులను నిల్వ చేయడానికి HashMapని ఉపయోగిస్తుంది, అయితే LinkedHashSet LinkedHashMapని ఉపయోగిస్తుంది . మీరు చొప్పించే క్రమాన్ని నిర్వహించాల్సిన అవసరం లేకుంటే, ప్రత్యేకమైన వస్తువులను నిల్వ చేయాల్సిన అవసరం ఉంటే, HashSetని ఉపయోగించడం మరింత సముచితం . మీరు మూలకాల చొప్పించే క్రమాన్ని నిర్వహించాల్సిన అవసరం ఉన్నట్లయితే, LinkedHashSet మీ ఎంపిక. LinkedHashSet పనితీరు HashSet కంటే కొంచెం నెమ్మదిగా ఉంటుంది, ఎందుకంటే ఎలిమెంట్‌ల చొప్పించే క్రమాన్ని నిర్వహించడానికి LinkedHashSet అంతర్గత లింక్డ్‌లిస్ట్‌ని ఉపయోగిస్తుంది. ఒక ఉదాహరణ చూద్దాం:
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);
   }
}
ప్రోగ్రామ్ యొక్క అవుట్‌పుట్:
రెగ్యులర్ హాష్‌సెట్ = [65536, 3, 5, 7, 9] లింక్డ్ హ్యాష్‌సెట్ = [7, 3, 5, 65536, 9]

వాస్తవ ప్రపంచ అనువర్తనాల్లో Java LinkedHashSetని ఉపయోగించడం

లింక్డ్‌హాష్‌సెట్ ఎంట్రీ ఉనికిని త్వరగా తనిఖీ చేయడానికి మరియు ఆర్డర్‌ను నిల్వ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది కాబట్టి , జాబితా నుండి నకిలీలను తొలగించడానికి ఈ సేకరణ చాలా సౌకర్యవంతంగా ఉంటుంది. లేదా, ఉదాహరణకు, నా బ్యాగ్‌లో ఇటీవల చూసిన వస్తువు వంటి సమస్యలను పరిష్కరించడం. లేదా, అలాంటి గేమ్, పోకీమాన్ గో గుర్తుందా? LinkedHashSet మీరు ఎదుర్కొన్న పోకీమాన్ జాబితాను మరియు అవి మీ మార్గంలో వచ్చిన క్రమాన్ని నిల్వ చేయగలదు. ఈ సందర్భంలో, "రిపీటెడ్" పోకీమాన్ ఇకపై జాబితాకు జోడించబడదు. లేదా, ఉదాహరణకు, మీరు ఇప్పటికే స్థాయిలతో ఏదైనా గేమ్‌లో కలుసుకున్న స్థాయిని బట్టి ఉన్నతాధికారుల జాబితా. లేదా విశ్వ శరీరాల ఆవిష్కరణ చరిత్ర. లింక్డ్‌హాష్‌సెట్స్పేస్ బాడీ ఇప్పటికే జాబితాలో ఉందో లేదో త్వరగా తనిఖీ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది మరియు అది అక్కడ లేకుంటే, దానిని జాబితాకు జోడించండి. నకిలీలను తొలగించడానికి ఒక ఉదాహరణ తీసుకుందాం.
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);
   }
}
ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది:
listWithDuplicates = [కొన్ని, మూలకాలు, కొన్ని, నకిలీలు, ఉన్నాయి, ఇక్కడ, నకిలీలు, నకిలీలు] listWithoutDuplicates = [కొన్ని, మూలకాలు, కొన్ని, నకిలీలు, ఉన్నాయి, ఇక్కడ] లింక్డ్HashSet = [కొన్ని, మూలకాలు, కొన్ని, నకిలీలతో, కొన్ని, నకిలీలు , are, here] regularHashSet = [ఇక్కడ, కొన్ని, నకిలీలతో, ఉన్నాయి, మూలకాలు, కొన్ని]
వ్యాఖ్యలు
  • జనాదరణ పొందినది
  • కొత్తది
  • పాతది
వ్యాఖ్యానించడానికి మీరు తప్పనిసరిగా సైన్ ఇన్ చేసి ఉండాలి
ఈ పేజీకి ఇంకా ఎలాంటి వ్యాఖ్యలు లేవు