सूची पुनरावृत्तियों की गारंटी सबसे पहले और सबसे महत्वपूर्ण है कि आपको सूची के आंतरिक क्रम में सूची के तत्व मिलते हैं (उर्फ प्रविष्टि आदेश )। अधिक विशेष रूप से यह उस क्रम में है जिसे आपने तत्वों को सम्मिलित किया है या आपने सूची में हेरफेर कैसे किया है। सॉर्टिंग को डेटा संरचना के हेरफेर के रूप में देखा जा सकता है, और सूची को सॉर्ट करने के कई तरीके हैं।
मैं उपयोगिता के क्रम में तरीके बताता हूँ जैसा कि मैं व्यक्तिगत रूप से देखता हूँ:
1. इसके बजाय उपयोग Setया Bagसंग्रह पर विचार करें
नोट: मैंने इस विकल्प को शीर्ष पर रखा है क्योंकि यह वही है जो आप सामान्य रूप से वैसे भी करना चाहते हैं।
सॉर्ट किए गए सेट स्वचालित रूप से प्रविष्टि में संग्रह को सॉर्ट करते हैं , जिसका अर्थ है कि जब आप संग्रह में तत्वों को जोड़ते हैं तो यह सॉर्टिंग करता है। इसका मतलब यह भी है कि आपको इसे मैन्युअल रूप से सॉर्ट करने की आवश्यकता नहीं है।
इसके अलावा यदि आप सुनिश्चित हैं कि आपको डुप्लिकेट तत्वों के बारे में चिंता करने की ज़रूरत नहीं है (या है) तो आप TreeSet<T>इसके बजाय उपयोग कर सकते हैं । यह लागू करता है SortedSetऔर NavigableSetइंटरफेस और काम करता है जैसा कि आप शायद एक सूची से उम्मीद करेंगे:
TreeSet<String> set = new TreeSet<String>();
set.add("lol");
set.add("cat");
// automatically sorts natural order when adding
for (String s : set) {
System.out.println(s);
}
// Prints out "cat" and "lol"
यदि आप प्राकृतिक ऑर्डर नहीं करना चाहते हैं तो आप कंस्ट्रक्टर पैरामीटर का उपयोग कर सकते हैं जो कि लेता है Comparator<T>।
वैकल्पिक रूप से, आप मल्टीसेट्स (जिसे बैग्स के रूप में भी जाना जाता है ) का उपयोग कर सकते हैं , यह एक Setऐसा है जो डुप्लिकेट तत्वों की अनुमति देता है, इसके बजाय तीसरे पक्ष के कार्यान्वयन हैं। सबसे विशेष रूप से अमरूद पुस्तकालयों में से एक है TreeMultiset, जो बहुत कुछ काम करता है TreeSet।
2. अपनी सूची के साथ क्रमबद्ध करें Collections.sort()
जैसा कि ऊपर उल्लेख किया गया है, एस की छंटनी Listडेटा संरचना का एक हेरफेर है। तो ऐसी स्थितियों के लिए जहां आपको "सत्य के एक स्रोत" की आवश्यकता होती है, जिसे विभिन्न तरीकों से क्रमबद्ध किया जाएगा फिर इसे मैन्युअल रूप से सॉर्ट करना है।
आप java.util.Collections.sort()विधि के साथ अपनी सूची को सॉर्ट कर सकते हैं । यहाँ कैसे पर एक कोड नमूना है:
List<String> strings = new ArrayList<String>()
strings.add("lol");
strings.add("cat");
Collections.sort(strings);
for (String s : strings) {
System.out.println(s);
}
// Prints out "cat" and "lol"
तुलना का उपयोग करना
एक स्पष्ट लाभ यह है कि आप विधि Comparatorमें उपयोग कर सकते हैं sort। जावा इस Comparatorतरह के लिए कुछ कार्यान्वयन प्रदान करता है Collatorजो स्थानीय संवेदनशील छंटाई के लिए उपयोगी है। यहाँ एक उदाहरण है:
Collator usCollator = Collator.getInstance(Locale.US);
usCollator.setStrength(Collator.PRIMARY); // ignores casing
Collections.sort(strings, usCollator);
समवर्ती वातावरण में छंटनी
ध्यान दें कि sortविधि का उपयोग करना समवर्ती वातावरण में अनुकूल नहीं है, क्योंकि संग्रह आवृत्ति में हेरफेर किया जाएगा, और आपको इसके बजाय अपरिवर्तनीय संग्रह का उपयोग करने पर विचार करना चाहिए। यह कुछ अमरूद है जो Orderingकक्षा में प्रदान करता है और एक साधारण लाइनर है:
List<string> sorted = Ordering.natural().sortedCopy(strings);
3. के साथ अपनी सूची लपेटें java.util.PriorityQueue
हालाँकि, जावा में कोई क्रमबद्ध सूची नहीं है, फिर भी एक क्रमबद्ध कतार है जो शायद आपके लिए भी काम करेगी। यह java.util.PriorityQueueवर्ग है।
नीको हासे टिप्पणियों से संबंधित एक प्रश्न से जुड़ा है जो इसका उत्तर भी देता है।
एक सॉर्ट किए गए संग्रह में, आप सबसे अधिक संभावना आंतरिक डेटा संरचना में हेरफेर नहीं करना चाहते हैं यही वजह है कि वरीयता इंटरफ़ेस सूची इंटरफ़ेस को लागू नहीं करता है (क्योंकि इससे आपको इसके तत्वों तक सीधी पहुंच मिलेगी)।
यात्रा करने वाले पर PriorityQueueकैविटी
PriorityQueueवर्ग के औजार Iterable<E>और Collection<E>इंटरफेस तो यह हमेशा की तरह दोहराया जा सकता है। हालांकि, पुनरावृत्त तत्वों को सॉर्ट किए गए क्रम में वापस करने की गारंटी नहीं है। इसके बजाय (जैसा कि अदरथ टिप्पणी में बताते हैं) आपको poll()खाली होने तक कतार में रहने की आवश्यकता है ।
ध्यान दें कि आप सूची को किसी भी संग्रह में लेने वाले कंस्ट्रक्टर के जरिए प्राथमिकता कतार में बदल सकते हैं :
List<String> strings = new ArrayList<String>()
strings.add("lol");
strings.add("cat");
PriorityQueue<String> sortedStrings = new PriorityQueue(strings);
while(!sortedStrings.isEmpty()) {
System.out.println(sortedStrings.poll());
}
// Prints out "cat" and "lol"
4. अपनी SortedListकक्षा लिखें
नोट: आपको ऐसा नहीं करना चाहिए।
आप अपनी सूची वर्ग लिख सकते हैं जो हर बार जब आप एक नया तत्व जोड़ते हैं। यह आपके कार्यान्वयन के आधार पर भारी गणना प्राप्त कर सकता है और व्यर्थ है , जब तक कि आप इसे अभ्यास के रूप में नहीं करना चाहते हैं, क्योंकि दो मुख्य कारण हैं:
- यह उस अनुबंध को तोड़ता है जो
List<E>इंटरफ़ेस में है क्योंकि addविधियों को यह सुनिश्चित करना चाहिए कि उपयोगकर्ता द्वारा निर्दिष्ट सूचकांक में तत्व निवास करेगा।
- पहिया को क्यों मजबूत करें? आपको पहले बिंदु पर बताए गए अनुसार ट्रीसेट या मल्टीसेट्स का उपयोग करना चाहिए।
हालाँकि, यदि आप इसे एक अभ्यास के रूप में करना चाहते हैं तो आपको शुरू करने के लिए एक कोड नमूना है, यह AbstractListअमूर्त वर्ग का उपयोग करता है :
public class SortedList<E> extends AbstractList<E> {
private ArrayList<E> internalList = new ArrayList<E>();
// Note that add(E e) in AbstractList is calling this one
@Override
public void add(int position, E e) {
internalList.add(e);
Collections.sort(internalList, null);
}
@Override
public E get(int i) {
return internalList.get(i);
}
@Override
public int size() {
return internalList.size();
}
}
ध्यान दें कि यदि आपने अपनी ज़रूरत के तरीकों को ओवरराइड नहीं किया है, तो डिफ़ॉल्ट कार्यान्वयन से AbstractListफेंक दिया जाएगा UnsupportedOperationException।
