બંને ઑબ્જેક્ટ્સને ક્રમમાં રાખવા માટેની વ્યાખ્યા આપે છે, પરંતુ અલગ રીતે: Comparable ક્લાસનો કુદરતી ક્રમ વ્યાખ્યાયિત કરે છે (ક્લાસ દ્વારા જ લાગુ કરવામાં આવે છે), જ્યારે Comparator અને વૈકલ્પિક ક્રમ વ્યાખ્યાયિત કરે છે (અલગ ઑબ્જેક્ટ). પસંદગી તેના પર આધારિત છે કે ક્રમ આંતરિક છે કે સ્થિતિ-આધારિત છે.
public 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 માં વારંવાર વ્યવહારિક અને साक્ષાત્કાર વિષય છે.