तुलनीय -java.lang.Comparable: int compareTo(Object o1)
एक तुलनीय वस्तु अन्य वस्तु के साथ तुलना करने में सक्षम है। वर्ग को अपने उदाहरणों की तुलना करने में सक्षम होने के लिए java.lang.Comparable इंटरफ़ेस को लागू करना चाहिए।
- प्रदान की गई वस्तु के साथ वर्तमान वस्तु की तुलना करने में सक्षम।
- इसका उपयोग करके हम
only one sort sequenceउदाहरणों के गुणों के आधार पर लागू कर सकते हैं। पूर्व:Person.id
- कुछ पूर्वनिर्धारित कक्षाएं जैसे स्ट्रिंग, रैपर कक्षाएं, दिनांक, कैलेंडर ने तुलनात्मक इंटरफ़ेस लागू किया है।
तुलनित्र -java.util.Comparator: int compare(Object o1, Object o2)
एक तुलनित्र वस्तु दो अलग-अलग वस्तुओं की तुलना करने में सक्षम है। वर्ग अपने उदाहरणों की तुलना नहीं कर रहा है, लेकिन कुछ अन्य वर्ग के उदाहरण हैं। इस तुलनित्र वर्ग को java.util.Comparator इंटरफ़ेस को लागू करना चाहिए।
- समान प्रकार के किसी भी दो वस्तुओं की तुलना करने में सक्षम।
- इसका उपयोग करके हम
many sort sequenceउदाहरणों के गुणों के आधार पर प्रत्येक को लागू और नाम दे सकते हैं। पूर्व:Person.id, Person.name, Person.age
- हम अनुकूलित छँटाई के लिए हमारे पूर्व-परिभाषित कक्षाओं के लिए तुलनित्र इंटरफ़ेस को लागू कर सकते हैं।
उदाहरण:
public class Employee implements Comparable<Employee> {
private int id;
private String name;
private int age;
private long salary;
// Many sort sequences can be created with different names.
public static Comparator<Employee> NameComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return e1.getName().compareTo(e2.getName());
}
};
public static Comparator<Employee> idComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
}
};
public Employee() { }
public Employee(int id, String name, int age, long salary){
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
// setters and getters.
// Only one sort sequence can be created with in the class.
@Override
public int compareTo(Employee e) {
//return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
//return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
if (this.id > e.id) {
return 1;
}else if(this.id < e.id){
return -1;
}else {
return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
}
}
public static void main(String[] args) {
Employee e1 = new Employee(5, "Yash", 22, 1000);
Employee e2 = new Employee(8, "Tharun", 24, 25000);
List<Employee> list = new ArrayList<Employee>();
list.add(e1);
list.add(e2);
Collections.sort(list); // call @compareTo(o1)
Collections.sort(list, Employee.nameComparator); // call @compare (o1,o2)
Collections.sort(list, Employee.idComparator); // call @compare (o1,o2)
}
}
- अनुकूलित छँटाई के लिए हम तुलनित्र @compare (o1, o2) के लिए जाते हैं अन्य परिदृश्यों के लिए हम तुलनीय @compareTo (ओ 1) के लिए जाते हैं, बदलते कोड के साथ यदि हम एक से अधिक फ़ील्ड को सॉर्ट करना चाहते हैं तो हम तुलनित्र का उपयोग करते हैं।
के लिए जावा 8 लैम्ब्डा: तुलनाकारी मेरी पोस्ट का संदर्भ लें।