ორივე განსაზღვრავს თუ როგორ მოვახდინოთ ობიექტების დალაგება, მაგრამ სხვადსხვა გზით: Comparable განსაზღვრავს კლასის ბუნებრივ დალაგებას (განხორციელებული თავად კლასის მხრიდან), ხოლო Comparator განსაზღვრავს , ალტერნატიულ დალაგებას (ცალკე ობიექტი). არჩევანი დამოკიდებულია იმაზე, არის თუ არა დალაგება inha`ერენტული თუ სიტუაციური.
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);
builder-სტილის 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-სა და Comparator-ს შორის განსხვავების გაგება გაძლევთ სამაძლეს სწორი არჩევანი გაიღოთ: Comparable კლასის ერთი врожденного დალაგებისთვის (ჩაშენებული, ნაგულისხმევი გამოყენებით), Comparator მრავალი ან გარე დალაგებების მოქნილობისთვის (იგივე მონაცემების დახარისხება სხვადსხვა ველებით, ან კლასების დალაგება რომელიც არ აკონტროლებთ).
თანამედროვე თხევადი Comparator API (comparing/thenComparing/reversed) მრავალ დონის დალაგებას დაკმაყოფილებელს ხდის.
ორივეს ათვისება — და რომელი როდის შესაფერი არის — აუცილებელია დალაგებული მონაცემთა სტრუქტურებთან სამუშაოდ და ხშირი პრაქტიკული და ინტერვიუს თემაა Java-ში.