तुलनित्र, छँटाई संग्रह

"हाय, अमीगो!"

"हाय, बिलाबो!"

"आज हम एक छोटे, लेकिन दिलचस्प और उपयोगी विषय की जाँच करेंगे: संग्रहों को क्रमबद्ध करना।"

"छँटाई जा रही है? मैंने उसके बारे में कुछ सुना है।"

"बहुत पहले, प्रत्येक प्रोग्रामर को सॉर्टिंग एल्गोरिदम लिखने में सक्षम होना पड़ता था। उन्हें लिखने में सक्षम था और उन्हें लिखना पड़ा। लेकिन वे दिन खत्म हो गए हैं। आज, अपना खुद का सॉर्टिंग कोड लिखना खराब फॉर्म माना जाता है, जैसे कि कुछ और पहले से ही फिर से लिखना का आविष्कार किया गया है।"

"जावा (और अन्य प्रोग्रामिंग भाषाओं) में, सॉर्टिंग पहले से ही लागू है।  आपका काम यह सीखना है कि जो पहले से मौजूद है उसका ठीक से उपयोग कैसे किया जाए। "

"ठीक है।"

" कलेक्शंस हेल्पर क्लास में एक स्टैटिक सॉर्ट मेथड है जिसका उपयोग संग्रहों को सॉर्ट करने के लिए किया जाता है - या अधिक सटीक रूप से, सूचियाँ। मैप्स और सेट्स में तत्वों का ऑर्डर / इंडेक्स नहीं होता है, इसलिए सॉर्ट करने के लिए कुछ भी नहीं है।"

"हाँ, मुझे याद है। मैंने संख्याओं की सूची को छाँटने के लिए एक बार इस विधि का उपयोग किया था।"

"शानदार। लेकिन यह विधि पहली नज़र में लगने की तुलना में कहीं अधिक शक्तिशाली है। यह न केवल संख्याओं को क्रमबद्ध कर सकती है, बल्कि किसी भी मानदंड के आधार पर किसी भी वस्तु को भी क्रमबद्ध कर सकती है। दो इंटरफेस विधि को ऐसा करने में मदद करते हैं: तुलनीय और तुलनित्र । "

"कभी-कभी आपको वस्तुओं को क्रमबद्ध करने की आवश्यकता होती है, संख्याओं की नहीं। उदाहरण के लिए, मान लीजिए कि आपके पास लोगों की एक सूची है, और आप उन्हें उम्र के अनुसार क्रमबद्ध करना चाहते हैं। हमारे पास इसके लिए तुलनात्मक इंटरफ़ेस है । "

"पहले मैं आपको एक उदाहरण दिखाता हूँ, और फिर सब कुछ स्पष्ट हो जाएगा:"

public class Woman implements Comparable<Woman>
{
public int age;

public Woman(int age) {
this.age = age;
}

public int compareTo(Woman o)
{
return this.age - o.age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Collections.sort(women);
}

"ऑब्जेक्ट्स को सॉर्ट करने के लिए, आपको पहले यह जानना होगा कि उनकी तुलना कैसे करें। इसके लिए, हम Comparable का उपयोग करते हैं। Comparable इंटरफ़ेस एक सामान्य है, जिसका अर्थ है कि यह एक प्रकार के तर्क को स्वीकार करता है। इसकी केवल एक सामान्य विधि है: ComparTo(T o)। यह विधि वर्तमान वस्तु (यह) और एक तर्क (ओ) के रूप में पारित वस्तु की तुलना करती है। दूसरे शब्दों में, हमें इस पद्धति को अपनी कक्षा में लागू करने की आवश्यकता है और फिर इसका उपयोग पारित वस्तु के साथ वर्तमान वस्तु (यह) की तुलना करने के लिए करें। "

"और कैसे काम करने के लिए तुलना करता है? मुझे उम्मीद थी कि पारित वस्तु अधिक या छोटी थी या नहीं, इस पर निर्भर करता है कि यह सही या गलत होगा।"

"चीजें यहां पेचीदा हैं। तुलना विधि सही/गलत नहीं लौटाती है। इसके बजाय, यह एक int देता है। यह वास्तव में सादगी के लिए किया जाता है।

"जब एक कंप्यूटर को यह निर्धारित करने की आवश्यकता होती है कि क्या एक संख्या दूसरी संख्या से अधिक है, तो यह पहली संख्या से दूसरी संख्या घटाता है और फिर परिणाम देखता है। यदि परिणाम 0 है, तो संख्याएँ बराबर होती हैं। यदि परिणाम शून्य से कम है , तो दूसरी संख्या बड़ी है। और यदि परिणाम शून्य से अधिक है, तो पहली संख्या बड़ी है।"

"वही तर्क यहाँ लागू होता है। विनिर्देश के अनुसार, यदि तुलना की गई वस्तुएँ समान हैं, तो तुलना विधि को शून्य वापस करना चाहिए। यदि तुलना विधि शून्य से अधिक संख्या लौटाती है, तो हमारी वस्तु पारित वस्तु से अधिक है।" यदि तुलना करने के लिए विधि शून्य से कम संख्या लौटाती है, तो 'यह' पास की गई वस्तु से कम है।"

"यह थोड़ा अजीब है।"

"हाँ, लेकिन यदि आप वस्तुओं की तुलना केवल कुछ संख्यात्मक गुणों के आधार पर कर रहे हैं, तो आप केवल एक को दूसरे से घटाकर उनके बीच के अंतर को वापस कर सकते हैं। ठीक उसी तरह जैसे यह ऊपर के उदाहरण में किया गया था।"

public int compareTo(Woman o)
{
return this.age - o.age;
}

"मुझे लगता है कि मैं सब कुछ समझता हूं। लेकिन शायद नहीं। लेकिन लगभग सब कुछ।"

"बढ़िया। अब एक और व्यावहारिक समस्या पर विचार करते हैं। मान लीजिए कि आपने चीन में महिलाओं के कपड़े बनाने के लिए एक अच्छी वेबसाइट लिखी है। आप अपने ग्राहकों का वर्णन करने के लिए एक महिला वर्ग का उपयोग करते हैं। आपने एक तालिका के साथ एक वेबपेज भी बनाया है जहाँ आप उन सभी को देख सकते हैं। लेकिन एक समस्या है..."

"योर वुमन ऑब्जेक्ट में न केवल एक उम्र होती है, बल्कि अन्य डेटा का एक पूरा समूह भी होता है: पहला नाम, अंतिम नाम, ऊंचाई, वजन, बच्चों की संख्या आदि।"

"उपयोगकर्ताओं की तालिका में बहुत सारे कॉलम हैं, और यहाँ सवाल है: आप अपने उपयोगकर्ताओं को विभिन्न मानदंडों के आधार पर कैसे क्रमबद्ध करते हैं? वजन, उम्र के अनुसार, अंतिम नाम से?"

"हम्म। हाँ, मैं अक्सर ऐसी तालिकाएँ देखता हूँ जो आपको स्तंभ के आधार पर क्रमित करने देती हैं। तो, आप यह कैसे करते हैं?"

"इसके लिए, हमारे पास दूसरा इंटरफ़ेस है जिसके बारे में मैं आज आपको बताना चाहता हूं: तुलनित्र इंटरफ़ेस। इसमें एक तुलना विधि भी है, लेकिन इसमें दो तर्क होते हैं, एक नहीं: int तुलना (T o1, T o2)। यहां बताया गया है कि यह कैसे है काम करता है:"

public class Woman
{
public int age;
public int childrenCount;
public int weight;
public int height;
public String name;

public Woman(int age) {
this.age = age;
}
}

public static void main(String[] args )
{
ArrayList<Woman> women = new ArrayList<Woman>();
women.add(new Woman(18));
women.add(new Woman(21));
women.add(new Woman(5));

Comparator<Woman> compareByHeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.height - o2.height;
}
};

Collections.sort(women, compareByHeight);
}

"तुलनित्र इंटरफ़ेस ऑब्जेक्ट तुलना तर्क को तुलना की जा रही वस्तुओं के वर्ग के अंदर नहीं छिपाता है। इसके बजाय, इसे एक अलग वर्ग में लागू किया जाता है।"

"तो, मैं कई वर्ग बना सकता हूं जो तुलनित्र इंटरफ़ेस को लागू करते हैं, और उनमें से प्रत्येक ने अलग-अलग गुणों की तुलना की है? एक में वजन, दूसरे में उम्र और तीसरे में ऊंचाई?"

"हाँ, यह बहुत सरल और सुविधाजनक है।"

"हम कलेक्शंस.सॉर्ट मेथड को कॉल करते हैं, वस्तुओं की एक सूची और दूसरे तर्क के रूप में एक अन्य विशेष वस्तु पास करते हैं, जो तुलनित्र इंटरफ़ेस को लागू करता है और आपको बताता है कि सॉर्टिंग प्रक्रिया में वस्तुओं के जोड़े की सही तुलना कैसे करें।"

"हम्म। मुझे लगता है कि मैं सब कुछ समझता हूं। मुझे कोशिश करने दो। मान लीजिए कि मुझे उपयोगकर्ताओं को वजन से क्रमबद्ध करना है। यह कुछ ऐसा होगा:"

Comparator<Woman> compareByWeight = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.weight - o2.weight;
}
};

Collections.sort(women, compareByWeight);

"हाँ बिल्कुल।"

"बढ़िया। लेकिन अगर मैं उल्टे क्रम में क्रमबद्ध करना चाहूं तो क्या होगा?"

"इसके बारे में सोचो। जवाब बहुत आसान है!"

"मुझे मिल गया! इस तरह:"

return o1.weight - o2.weight;

return o2.weight – o1.weight;

"ठीक है। शाबाश।"

"और अगर मैं अंतिम नाम से सॉर्ट करना चाहता हूं? मैं स्ट्रिंग्स को कैसे सॉर्ट करूं, बिलाबो?"

"स्ट्रिंग वर्ग पहले से ही तुलना विधि लागू करता है। आपको बस इसे कॉल करने की आवश्यकता है:"

Comparator<Woman> compareByName = new Comparator<Woman>() {
public int compare(Woman o1, Woman o2) {
return o1.name.compareTo(o2.name);
}
};

Collections.sort(women, compareByName);

"वह एक महान सबक था, बिलाबो। बहुत-बहुत धन्यवाद।"

"और आपको धन्यवाद, मेरे दोस्त!"