ਦੋਵੇਂ ਵਸਤੂਆਂ ਨੂੰ ਆਦੇਸ ਦੇਣ ਦਾ ਤਰੀਕਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ, ਪਰ ਵੱਖਰੇ ਤਰੀਕਿਆਂ ਨਾਲ: 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-ਬਨਾਮ-Comparator ਫਰਕ ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਚੁਣਨ ਦਿੰਦਾ ਹੈ: Comparable ਇੱਕ ਵਰਗ ਦੀ ਸਿੰਗਲ ਅੰਦਰੂਨੀ ਆਦੇਸ਼ ਲਈ (ਬਣਿਆ ਹੋਇਆ, ਡਿਫਾਲਟ ਵਰਤੋਂ), Comparator ਕਈ ਜਾਂ ਬਾਹਰੀ ਆਦੇਸ਼ ਦੀ ਲਚਕ ਲਈ (ਉਸੇ ਡੇਟਾ ਨੂੰ ਵੱਖਰੇ ਫੀਲਡਾਂ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕਰਨਾ, ਜਾਂ ਕਿਸਮਾਂ ਦਾ ਆਦੇਸ਼ ਦੇਣਾ ਜੋ ਤੁਹਾਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਨਹੀਂ ਕਰਦੀਆਂ)।
ਆਧੁਨਿਕ ਤਰਲ Comparator API (comparing/thenComparing/reversed) ਬਹੁ-ਸਤਰ ਸਾਜ਼ਿਸ਼ ਨੂੰ ਸੁੰਦਰ ਬਣਾਉਂਦੀ ਹੈ।
ਦੋਵੇਂ ਵਿੱਚ ਮਾਹਰ ਹੋਣਾ — ਅਤੇ ਜਦੋਂ ਹਰੇਕ ਫਿਟ ਹੁੰਦਾ ਹੈ — ਕ੍ਰਮਬੱਧ ਡੇਟਾ ਢਾਂਚੇ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਮਾਮੂਲੀ ਹੈ ਅਤੇ Java ਵਿੱਚ ਇੱਕ ਬਾਰ-ਬਾਰ ਵਿਹਾਰਕ ਅਤੇ ਸਾਖਾ ਤਕ ਹੈ।