ஜாவாவில் என்ன அமைக்கப்பட்டுள்ளது
தொகுப்பு இடைமுகம் ஒரு தொகுப்பை (தொகுப்பு) வரையறுக்கிறது என்பதை சுருக்கமாக நினைவு கூர்வோம் . இது சேகரிப்பை விரிவுபடுத்துகிறது மற்றும் நகல் கூறுகளை அனுமதிக்காத சேகரிப்புகளின் நடத்தையை வரையறுக்கிறது. எனவே, தொகுப்பில் நகல் உறுப்பைச் சேர்க்க முயற்சித்தால், 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() இந்த தொகுப்பில் உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது (அதன் உறுப்புகளின் எண்ணிக்கை).
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);
}
}
வெளியீடு:
எடுத்துக்காட்டு 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);
}
}
நிரலின் வெளியீடு இங்கே:
எடுத்துக்காட்டு 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);
}
}
நிரலின் வெளியீடு இங்கே:
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);
}
}
நிரலின் வெளியீடு:
நிஜ உலகப் பயன்பாடுகளில் 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);
}
}
நிரலின் வெளியீடு இங்கே:
GO TO FULL VERSION