तुलनाकर्ता, संग्रह वर्गीकरण

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

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

"आज आम्ही एका लहान, परंतु मनोरंजक आणि उपयुक्त विषयाचे परीक्षण करू: संग्रहांची क्रमवारी लावणे."

"सॉर्टिंग? मी त्याबद्दल काहीतरी ऐकले आहे."

"फार पूर्वी, प्रत्येक प्रोग्रामरला क्रमवारी लावणारे अल्गोरिदम लिहिण्यास सक्षम असायचे. ते लिहिण्यास सक्षम होते आणि ते लिहायचे होते. परंतु ते दिवस संपले आहेत. आज तुमचा स्वतःचा क्रमवारी कोड लिहिणे हा वाईट प्रकार मानला जातो, जसे की इतर कोणत्याही गोष्टीचे पुनर्लेखन करणे. शोध लावला आहे."

"जावा (आणि इतर प्रोग्रामिंग भाषांमध्ये), क्रमवारी आधीच लागू केलेली आहे.  आधीच अस्तित्वात असलेल्या गोष्टींचा योग्य वापर कसा करायचा हे शिकणे हे तुमचे कार्य आहे. "

"ठीक आहे."

" कलेक्शन हेल्पर क्लासमध्ये एक स्थिर क्रमवारी पद्धत आहे जी संग्रहांची क्रमवारी लावण्यासाठी वापरली जाते—किंवा अधिक अचूकपणे, सूची. नकाशे आणि सेट्समधील घटकांना ऑर्डर/इंडेक्स नाही, त्यामुळे क्रमवारी लावण्यासाठी काहीही नाही."

"होय, मला आठवतंय. मी ही पद्धत एकदा नंबरची यादी लावण्यासाठी वापरली होती."

"उत्तम. परंतु ही पद्धत पहिल्या दृष्टीक्षेपात दिसते त्यापेक्षा खूप शक्तिशाली आहे. ती कोणत्याही निकषांवर आधारित केवळ संख्याच नव्हे तर कोणत्याही वस्तू देखील क्रमवारी लावू शकते. दोन इंटरफेस या पद्धतीला हे करण्यास मदत करतात: तुलनात्मक आणि तुलनाकर्ता . "

"कधीकधी तुम्हाला वस्तूंची क्रमवारी लावावी लागते, संख्या नाही. उदाहरणार्थ, समजा तुमच्याकडे लोकांची यादी आहे आणि तुम्हाला त्यांची वयानुसार क्रमवारी लावायची आहे. आमच्याकडे यासाठी तुलना करण्यायोग्य इंटरफेस आहे . "

"आधी मी तुम्हाला एक उदाहरण दाखवतो आणि मग सर्व काही स्पष्ट होईल:"

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);
}

"ऑब्जेक्ट्सची क्रमवारी लावण्यासाठी, तुम्हाला त्यांची तुलना कशी करायची हे प्रथम माहित असणे आवश्यक आहे. यासाठी, आम्ही तुलना करण्यायोग्य वापरतो. तुलना करण्यायोग्य इंटरफेस एक सामान्य आहे, याचा अर्थ असा की तो एक प्रकारचा युक्तिवाद स्वीकारतो. त्याची फक्त एक सामान्य पद्धत आहे: compareTo(To). ही पद्धत वर्तमान ऑब्जेक्ट (हे) आणि वितर्क (o) म्हणून उत्तीर्ण केलेल्या ऑब्जेक्टची तुलना करते. दुसऱ्या शब्दांत, आपल्याला ही पद्धत आपल्या वर्गात लागू करावी लागेल आणि नंतर पास केलेल्या ऑब्जेक्टशी वर्तमान ऑब्जेक्ट (या) ची तुलना करण्यासाठी ती वापरावी लागेल. "

"आणि कामाची तुलना कशी होते? पास केलेली वस्तू मोठी किंवा लहान आहे यावर अवलंबून ते खरे किंवा खोटे परत येईल अशी मला अपेक्षा होती."

"येथे गोष्टी अधिक अवघड आहेत. compareTo पद्धत सत्य/असत्य परत करत नाही. त्याऐवजी, ती एक int मिळवते. हे प्रत्यक्षात साधेपणासाठी केले जाते.

"जेव्हा संगणकाला एक संख्या दुसर्‍या पेक्षा मोठी आहे की नाही हे निर्धारित करणे आवश्यक असते, तेव्हा तो फक्त पहिल्या मधून दुसरी संख्या वजा करतो आणि नंतर निकाल पाहतो. जर निकाल 0 असेल, तर संख्या समान असतील. जर निकाल शून्यापेक्षा कमी असेल तर , तर दुसरी संख्या मोठी आहे. आणि जर निकाल शून्यापेक्षा मोठा असेल, तर पहिला क्रमांक मोठा असेल."

"हेच तर्क इथे लागू होते. विनिर्देशानुसार, तुलना केलेल्या वस्तू समान असल्यास compareTo पद्धतीने शून्य दिले पाहिजे. जर compareTo पद्धत शून्यापेक्षा मोठी संख्या दर्शवते, तर आमचा ऑब्जेक्ट पास केलेल्या ऑब्जेक्टपेक्षा मोठा असेल. "जर compareTo पद्धत शून्यापेक्षा कमी संख्या मिळवते, नंतर 'हे' पास केलेल्या ऑब्जेक्टपेक्षा कमी असते."

"ते थोडे विचित्र आहे."

"होय, पण जर तुम्ही फक्त काही संख्यात्मक गुणधर्माच्या आधारे वस्तूंची तुलना करत असाल, तर तुम्ही त्यांच्यातील फरक दुसर्‍यामधून वजा करून परत करू शकता. वरील उदाहरणात जसे केले होते तसे."

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

"मला वाटतं मला सगळं कळतं. पण कदाचित नाही. पण जवळपास सगळंच."

"छान. आता अधिक व्यावहारिक समस्येचा विचार करूया. समजा तुम्ही चीनमध्ये महिलांचे कपडे बनवण्यासाठी एक छान वेबसाइट लिहिली आहे. तुम्ही तुमच्या ग्राहकांचे वर्णन करण्यासाठी एक महिला वर्ग वापरता. तुम्ही टेबल असलेले वेबपेज देखील बनवले आहे जिथे तुम्ही ते सर्व पाहू शकता. पण एक अडचण आहे..."

"तुमच्या स्त्री ऑब्जेक्टमध्ये केवळ वयच नाही तर इतर डेटाचा संपूर्ण समूह देखील आहे: नाव, आडनाव, उंची, वजन, मुलांची संख्या इ.

"वापरकर्त्यांच्या सारणीमध्ये बरेच स्तंभ आहेत, आणि येथे प्रश्न आहे: तुम्ही तुमच्या वापरकर्त्यांना विविध निकषांनुसार कसे क्रमवारी लावाल? वजनानुसार, वयानुसार, आडनावानुसार?"

"हम्म. होय, मी अनेकदा टेबल्स पाहतो जे तुम्हाला कॉलमनुसार क्रमवारी लावू देतात. मग तुम्ही ते कसे करता?"

"यासाठी, आमच्याकडे दुसरा इंटरफेस आहे ज्याबद्दल मी तुम्हाला आज सांगू इच्छितो: तुलनाकर्ता इंटरफेस. यात तुलना करण्याची पद्धत देखील आहे, परंतु त्यासाठी दोन युक्तिवाद लागतात, एक नाही: int compare(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);
}

"तुलनाकर्ता इंटरफेस तुलना केल्या जात असलेल्या ऑब्जेक्ट्सच्या वर्गामध्ये ऑब्जेक्ट तुलना तर्क लपवत नाही. त्याऐवजी, ते वेगळ्या वर्गात लागू केले जाते."

"म्हणून, मी कम्पॅरेटर इंटरफेस लागू करणारे अनेक वर्ग बनवू शकेन आणि त्या प्रत्येकामध्ये वेगवेगळ्या गुणधर्मांची तुलना करता येईल? एकामध्ये वजन, दुसऱ्यामध्ये वय आणि तिसऱ्यामध्ये उंची?"

"होय, हे खूप सोपे आणि सोयीस्कर आहे."

"आम्ही फक्त Collections.sort पद्धत म्हणतो , ऑब्जेक्ट्सची यादी आणि दुसरा वितर्क म्हणून आणखी एक विशेष ऑब्जेक्ट पास करतो, जो Comparator इंटरफेस लागू करतो आणि सॉर्टिंग प्रक्रियेत ऑब्जेक्ट्सच्या जोड्यांची योग्यरित्या तुलना कशी करायची ते सांगते."

"हम्म. मला वाटते की मला सर्व काही समजले आहे. मला ते वापरून पहा. समजू की मला वापरकर्त्यांना वजनानुसार क्रमवारी लावायची आहे. हे असे काहीतरी असेल:"

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;

"बरोबर. छान केले."

"आणि जर मला आडनावानुसार क्रमवारी लावायची असेल तर मी स्ट्रिंग्सची क्रमवारी कशी लावू, बिलाबो?"

"स्ट्रिंग क्लास आधीपासून compareTo पद्धत लागू करतो. तुम्हाला फक्त कॉल करणे आवश्यक आहे:"

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

Collections.sort(women, compareByName);

"तो एक छान धडा होता, बिलाबो. खूप खूप धन्यवाद."

"आणि तुझे आभार, माझ्या मित्रा!"