CodeGym/Java Blog/சீரற்ற/ஜாவாவில் LinkedHashSet
John Squirrels
நிலை 41
San Francisco

ஜாவாவில் LinkedHashSet

சீரற்ற குழுவில் வெளியிடப்பட்டது
members
ஜாவாவில் லிங்க்ட்ஹாஷ்செட் வகுப்பைப் பற்றி பேசுகையில் , இது செட் இடைமுகத்தை செயல்படுத்துகிறது என்பதை நாம் குறிப்பிட வேண்டும். LinkedHashSet ஒரு தொகுப்பை உருவாக்குகிறது, இது ஒரு ஹாஷ் அட்டவணையில் கூறுகளை சேமிக்கிறது, ஆனால் அதன் HashSet எண்ணைப் போலல்லாமல் உறுப்புகளின் செருகும் வரிசையை பராமரிக்கிறது.

ஜாவாவில் என்ன அமைக்கப்பட்டுள்ளது

தொகுப்பு இடைமுகம் ஒரு தொகுப்பை (தொகுப்பு) வரையறுக்கிறது என்பதை சுருக்கமாக நினைவு கூர்வோம் . இது சேகரிப்பை விரிவுபடுத்துகிறது மற்றும் நகல் கூறுகளை அனுமதிக்காத சேகரிப்புகளின் நடத்தையை வரையறுக்கிறது. எனவே, தொகுப்பில் நகல் உறுப்பைச் சேர்க்க முயற்சித்தால், add() முறை தவறானதாகத் திரும்பும் . இடைமுகம் அதன் சொந்த கூடுதல் முறைகளை வரையறுக்கவில்லை. செட் இடைமுகம் சேமிக்கப்பட்ட பொருட்களின் தனித்துவத்தை கவனித்துக்கொள்கிறது, சமமான () முறையை செயல்படுத்துவதன் மூலம் தனித்துவம் தீர்மானிக்கப்படுகிறது . எனவே, உருவாக்கப்பட்ட வகுப்பின் பொருள்கள் தொகுப்பில் சேர்க்கப்பட்டால் , சமன்() முறையை மேலெழுதுவது விரும்பத்தக்கது .

LinkedHashSet வகுப்பு

LinkedHashSet வகுப்பைப் பற்றி பேசுவதற்கு முன் , அதன் நெருங்கிய உறவினரான HashSet வகுப்பைக் குறிப்பிட வேண்டும் . HashSet செட் இடைமுகத்தை செயல்படுத்துகிறது . இது ஒரு ஹாஷ் அட்டவணையில் கூறுகளை சேமிக்கும் தொகுப்பை உருவாக்குகிறது. ஹாஷ் அட்டவணையின் கூறுகள் முக்கிய மதிப்பு ஜோடிகளாக சேமிக்கப்படும். விசையானது மதிப்பைச் சேமிக்க கலத்தை (அல்லது பிரிவு) குறிப்பிடுகிறது. ஹாஷ் குறியீடு எனப்படும் தனித்துவமான மதிப்பைத் தீர்மானிக்க விசையின் உள்ளடக்கம் பயன்படுத்தப்படுகிறது. ஹாஷ் குறியீட்டை ஒரு பொருள் அடையாளங்காட்டியாக நாம் நினைக்கலாம், இருப்பினும் அது தனிப்பட்டதாக இருக்க வேண்டியதில்லை. இந்த ஹாஷ் குறியீடு, விசையுடன் தொடர்புடைய தரவு சேமிக்கப்படும் ஒரு குறியீடாகவும் செயல்படுகிறது. LinkedHashSet ஜாவா வகுப்பு எந்த புதிய முறைகளையும் சேர்க்காமல் HashSet ஐ நீட்டிக்கிறது.LinkedHashSet ஆனது HashSet போலவே உள்ளீட்டின் இருப்பை விரைவாகச் சரிபார்க்க உங்களை அனுமதிக்கிறது , ஆனால் உள்ளே வரிசைப்படுத்தப்பட்ட பட்டியலைக் கொண்டுள்ளது. இதன் பொருள் இது உறுப்புகளின் செருகும் வரிசையை சேமிக்கிறது. வேறு வார்த்தைகளில் கூறுவதானால், LinkedHashSet அவர்கள் செருகப்பட்ட வரிசையில் தொகுப்பு உறுப்புகளின் இணைக்கப்பட்ட பட்டியலை பராமரிக்கிறது. இது ஒரு தொகுப்பில் வரிசைப்படுத்தப்பட்ட செருகலை அனுமதிக்கிறது. ஆனால் இது LinkedHashSet வகுப்பை HashSet வகுப்பை விட நீண்ட நேரம் செயல்பட வைக்கிறது .

LinkedHashSet இன் முக்கிய அம்சங்கள்

  • நாம் ஒரு LinkedHashSet இல் மட்டுமே தனிப்பட்ட கூறுகளை சேமிக்க முடியும்

  • LinketHashSet நாம் செருகும் அதே வரிசையில் உறுப்புகளைப் பிரித்தெடுக்கலாம்

  • LinkedHashSet ஒத்திசைக்கப்படவில்லை

  • LinkedHashSet பூஜ்ய கூறுகளை சேமிக்க அனுமதிக்கிறது

  • LinkedHashSet ஒரு ஹாஷ் குறியீட்டின் அடிப்படையில் ஒரு குறிப்பிட்ட குறியீட்டில் கூறுகளைச் சேமிக்க ஹாஷிங் நுட்பத்தைப் பயன்படுத்துகிறது.

LinkedHashSet முறைகள்

அதன் பெற்றோர் வகுப்புகளிலிருந்து பெறப்பட்ட முறைகளுக்கு கூடுதலாக, HashSet பின்வரும் முறைகளை வரையறுக்கிறது:
  • boolean add(Object o) குறிப்பிட்ட உறுப்பை இந்த தொகுப்பில் சேர்க்கும்.

  • void clear() இந்த தொகுப்பிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது.

  • பொருள் குளோன்() இந்த LinkedHashSet நிகழ்வின் ஆழமற்ற நகலை வழங்குகிறது : உறுப்புகள் குளோன் செய்யப்படவில்லை.

  • இந்த தொகுப்பில் குறிப்பிடப்பட்ட உறுப்பு இருந்தால் boolean contains(Object o) உண்மை என்பதை வழங்குகிறது.

  • இந்த தொகுப்பில் எந்த உறுப்புகளும் இல்லை என்றால் boolean isEmpty() உண்மை என வழங்கும் .

  • இட்டரேட்டர் இடிரேட்டர்() இந்த தொகுப்பின் உறுப்புகளுக்கு மேல் ஒரு இட்டேட்டரை வழங்குகிறது.

  • boolean remove(Object o) இந்த தொகுப்பிலிருந்து குறிப்பிட்ட உறுப்பு இருந்தால், அதை நீக்குகிறது.

  • int size() இந்த தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது (அதன் உறுப்புகளின் எண்ணிக்கை).

எளிதான LinkedHashSet எடுத்துக்காட்டுகள் கீழே உள்ள எடுத்துக்காட்டில் LinkedHashSet பொருளின் துவக்கத்தையும், தொகுப்பை நிரப்ப 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]
நீங்கள் பார்க்க முடியும் என, எங்கள் தொகுப்பில் உள்ள கூறுகள் நாங்கள் அவற்றை வைத்த அதே வரிசையில் தோன்றின. ஜாவாவில் LinkedHashSet - 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] false கூறுகள் அகற்றப்படாமல் எங்கள் தொகுப்பை அச்சிடுக: [Re, Do, Sol, La, Ti, Mi] தெளிவான கட்டளைக்குப் பிறகு எங்கள் தொகுப்பை அச்சிடுக: []
நீங்கள் பார்க்கிறபடி, இல்லாத உறுப்புக்கு பயன்படுத்தப்படும் நீக்க() முறை நிரல் பிழையை ஏற்படுத்தாது. உறுப்பு அகற்றப்படாவிட்டால் அது வெறுமனே தவறானதாகவும் , உறுப்பு LinkedHashSet இல் இருந்து பின்னர் அகற்றப்பட்டால் அது உண்மையாகவும் இருக்கும்.

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 ஒரு நுழைவு இருப்பதை விரைவாகச் சரிபார்க்க உங்களை அனுமதிக்கிறது மற்றும் ஆர்டரைச் சேமிப்பதால், பட்டியலிலிருந்து நகல்களை அகற்ற இந்தத் தொகுப்பு மிகவும் வசதியாகத் தெரிகிறது . அல்லது, எடுத்துக்காட்டாக, எனது பையில் சமீபத்தில் பார்த்த உருப்படி போன்ற சிக்கல்களைத் தீர்ப்பது. அல்லது, போக்கிமான் கோ போன்ற விளையாட்டு நினைவிருக்கிறதா? 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 = [சில, உறுப்புகள், உடன், சில, நகல், இருந்தன, இங்கே] linkedHashSet = [சில, உறுப்புகள், உடன், சில, நகல்கள் , are, here] regularHashSet = [இங்கே, சில, நகல்களுடன், இருந்தன, உறுப்புகள், சில]
கருத்துக்கள்
  • பிரபலமானவை
  • புதியவை
  • பழையவை
ஒரு கருத்தைத் தெரிவிக்க நீங்கள் உள்நுழைந்திருக்க வேண்டும்
இந்தப் பக்கத்தில் இதுவரை எந்தக் கருத்தும் வழங்கப்படவில்லை