Java मध्ये काय सेट आहे
आपण थोडक्यात लक्षात ठेवूया की सेट इंटरफेस सेट (सेट) परिभाषित करतो. हे संकलन विस्तारित करते आणि डुप्लिकेट घटकांना अनुमती न देणार्या संग्रहांचे वर्तन परिभाषित करते. अशा प्रकारे, सेटमध्ये डुप्लिकेट घटक जोडण्याचा प्रयत्न केल्यास add() पद्धत चुकीची दर्शवते. इंटरफेस स्वतःच्या कोणत्याही अतिरिक्त पद्धती परिभाषित करत नाही. सेट इंटरफेस संग्रहित वस्तूंच्या विशिष्टतेची काळजी घेतो, विशिष्टता equals() पद्धतीच्या अंमलबजावणीद्वारे निर्धारित केली जाते . म्हणून, जर तयार केलेल्या वर्गाच्या वस्तू सेटमध्ये जोडल्या गेल्या असतील तर , equals() पद्धत ओव्हरराइड करणे इष्ट आहे .LinkedHashSet वर्ग
LinkedHashSet वर्गाबद्दल बोलण्यापूर्वी , आपण त्याच्या जवळच्या नातेवाईक, हॅशसेट वर्गाचा उल्लेख करणे आवश्यक आहे. हॅशसेट सेट इंटरफेस लागू करतो . हे एक संग्रह तयार करते जे घटकांना हॅश टेबलमध्ये संग्रहित करते. हॅश टेबलचे घटक की-व्हॅल्यू जोड्या म्हणून संग्रहित केले जातात. मूल्य संचयित करण्यासाठी की सेल (किंवा विभाग) निर्दिष्ट करते. हॅश कोड नावाचे अद्वितीय मूल्य निर्धारित करण्यासाठी कीची सामग्री वापरली जाते. आपण हॅश कोडला ऑब्जेक्ट आयडेंटिफायर म्हणून विचार करू शकतो, जरी तो अद्वितीय असणे आवश्यक नाही. हा हॅश कोड निर्देशांक म्हणून देखील काम करतो ज्यामध्ये कीशी संबंधित डेटा संग्रहित केला जातो. LinkedHashSet Java वर्ग कोणत्याही नवीन पद्धती न जोडता हॅशसेटचा विस्तार करतो.LinkedHashSet तुम्हाला HashSet प्रमाणेच एंट्रीचे अस्तित्व त्वरीत तपासण्याची परवानगी देतो , परंतु आत ऑर्डर केलेली यादी आहे. याचा अर्थ असा की ते घटकांचा अंतर्भूत क्रम संग्रहित करते. दुस-या शब्दात, LinkedHashSet सेट घटकांची लिंक केलेली सूची ते समाविष्ट केल्यानुसार ठेवते. हे सेटमध्ये समाविष्ट करण्याच्या क्रमाने पुनरावृत्ती करण्यास अनुमती देते. परंतु यामुळे LinkedHashSet क्लास हॅशसेट क्लासपेक्षा जास्त काळ ऑपरेशन करू शकतो .LinkedHashSet ची महत्वाची वैशिष्ट्ये
-
आम्ही फक्त LinkedHashSet मध्ये अद्वितीय घटक संचयित करू शकतो
-
LinketHashSet आपण टाकतो त्याच क्रमाने घटक काढू
-
LinkedHashSet सिंक्रोनाइझ केलेले नाही
-
LinkedHashSet शून्य घटक संचयित करण्यास अनुमती देते
-
LinkedHashSet हॅश कोडवर आधारित निर्दिष्ट निर्देशांकावर घटक संचयित करण्यासाठी हॅशिंग तंत्र वापरते
LinkedHashSet पद्धती
त्याच्या पालक वर्गांकडून मिळालेल्या पद्धतींव्यतिरिक्त, हॅशसेट खालील पद्धती परिभाषित करते:-
बूलियन अॅड(ऑब्जेक्ट ओ) या सेटमध्ये निर्दिष्ट घटक जोडतो जर तो आधीपासून उपस्थित नसेल.
-
void clear() या संचातील सर्व घटक काढून टाकते.
-
ऑब्जेक्ट क्लोन() या LinkedHashSet उदाहरणाची उथळ प्रत परत करते : घटक स्वतः क्लोन केलेले नाहीत.
-
जर या सेटमध्ये निर्दिष्ट घटक समाविष्ट असेल तर boolean contains(Object o) सत्य मिळवते.
-
या सेटमध्ये कोणतेही घटक नसल्यास boolean isEmpty() खरे मिळवते .
-
Iterator iterator() या संचाच्या घटकांवर पुनरावृत्ती करणारा परत करतो.
-
बुलियन रिमूव्ह (ऑब्जेक्ट ओ) या सेटमधून निर्दिष्ट घटक काढून टाकते, जर उपस्थित असेल.
-
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 LinkedHashMap वापरते . जर तुम्हाला इन्सर्शन ऑर्डर राखण्याची गरज नसेल परंतु युनिक ऑब्जेक्ट्स साठवण्याची गरज असेल, तर हॅशसेट वापरणे अधिक योग्य आहे . जर तुम्हाला घटकांचा समावेश क्रम राखायचा असेल तर LinkedHashSet ही तुमची निवड आहे. LinkedHashSet ची कार्यक्षमता HashSet पेक्षा थोडी धीमी आहे कारण LinkedHashSet घटकांचा अंतर्भूत क्रम राखण्यासाठी अंतर्गत LinkedList वापरतो. चला एक उदाहरण घेऊ:
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