இரண்டும் பொருட்களை வரிசைப்படுத்துவது எப்படி என்பதை வரையறுக்கின்றன, ஆனால் வெவ்வேறு வழிகளில்: Comparable வகுப்பின் இயற்கையான வரிசைப்படுத்தலை வரையறுக்கிறது (வகுப்பாலேயே செயல்படுத்தப்படுகிறது), அதே சமயம் , மாற்று வரிசைப்படுத்தலை வரையறுக்கிறது (ஒரு தனி பொருள்). தேர்வு வரிசைப்படுத்தல் உள்ளார்ந்ததா அல்லது சூழ்நிலை சார்ந்ததா என்பதைப் பொறுத்தது.
Comparatorpublic class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public int compareTo(Person other) { // defines THE natural order
return Integer.compare(this.age, other.age); // by age
}
// return: negative if this < other, 0 if equal, positive if this > other
}
List<Person> people = ...;
Collections.sort(people); // uses compareTo — sorts by age (the natural order)
Comparable compareTo() வழியாக வகுப்பிற்குள் இருக்கிறது, அதன் ஒரே, முன்னிருப்பு வரிசைப்படுத்தலை வரையறுக்கிறது. இது Collections.sort, TreeSet, TreeMap போன்றவற்றால் தானாகவே பயன்படுத்தப்படுகிறது.
// define orderings OUTSIDE the class — as many as you need
Comparator<Person> byName = (a, b) -> a.getName().compareTo(b.getName());
Comparator<Person> byAge = Comparator.comparingInt(Person::getAge);
people.sort(byName); // sort by name
people.sort(byAge.reversed()); // by age, descending
Comparator ஒரு தனி பொருள், இது உங்களை ஒரே வகுப்பிற்கான பல வெவ்வேறு வரிசைப்படுத்தலை வரையறுக்க அனுமதிக்கிறது அதை மாற்றாமல்.
Comparator<Person> comp = Comparator
.comparing(Person::getLastName) // primary: last name
.thenComparing(Person::getFirstName) // tie-break: first name
.thenComparingInt(Person::getAge) // then: age
.reversed(); // reverse the whole thing
people.sort(comp);
comparing/thenComparing வகையான தொகுப்பாளர் முறைகள் சிக்கலான பல-புல வரிசைப்படுத்தலை சுருக்கமாக மற்றும் படிக்க முடியுமாக மாற்றுகின்றன.
Comparable → the class has ONE obvious natural order (numbers by value, strings
alphabetically, dates chronologically); you own the class
Comparator → you need MULTIPLE orderings, situational/custom ordering, OR you
can't modify the class (e.g. sorting a third-party type differently)
பொருட்களை வரிசைப்படுத்துவது ஒரு நிரந்தர தேவை — பட்டியல்களை வரிசைப்படுத்துதல், TreeSet/TreeMap பயன்படுத்துதல், குறைந்தபட்சம்/அதிகபட்சம் கண்டறிதல்।
Comparable-vs-Comparator வேறுபாட்டை புரிந்துகொள்வது உங்களை சரியாக தேர்வு செய்ய அனுமதிக்கிறது: Comparable வகுப்பின் ஒரே உள்ளார்ந்த வரிசைப்படுத்தலுக்கு (உள்ளமைந்துள்ளது, முன்னிருப்பாக பயன்படுத்தப்படுகிறது), Comparator பல அல்லது வெளிப்புற வரிசைப்படுத்தलின் நমনীয়தার்க்கு (ஒரே தரவுகளை வெவ்வேறு புலங்களால் வரிசைப்படுத்தவும் அல்லது நீங்கள் கட்டுப்பாடு செய்யாத வகைகளை வரிசைப்படுத்தவும்)।
আধুনिক சरल Comparator API (comparing/thenComparing/reversed) பல-நிலை வரிசைப்படுத்தலை நேர்த்தியாக மாற்றுகிறது।
இரண்டையும் தெளிவாக புரிந்துகொள்ளுதல் — மற்றும் ஒவ்வொன்று எப்போது பொருத்தமாகும் என்பது — வரிசைப்படுத்தப்பட்ட தரவு கட்டமைப்புகளுடன் பணிபுரிவதற்கு அপরिहार்यமாகும் மற்றும் Java இல் அடிக்கடி நடைமுறை மற்றும் நேர்காணல் வினாவாகும்।