Mitä eroa on Comparable- ja Comparator-rajapinnalla?

Question

Accepted Answer

Molemmat määrittävät, miten **objektit järjestetään**, mutta eri tavoin: **`Comparable`** määrittää luokan *luonnollisen* järjestyksen (luokka toteuttaa sen itse), kun taas **`Comparator`** määrittää *ulkoisen*, vaihtoehtoisen järjestyksen (erillinen objekti). Valinta riippuu siitä, onko järjestys luontainen vai tilannekohtainen. ## Comparable — luonnollinen järjestys (yksi, luokkaan rakennettu) ```java public class Person implements Comparable { 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 people = ...; Collections.sort(people); // uses compareTo — sorts by age (the natural order) ``` `Comparable` sijaitsee luokan *sisällä* `compareTo()`-metodin kautta, määrittäen sen yhden oletusarvoisen järjestyksen. Sitä käyttävät automaattisesti `Collections.sort`, `TreeSet`, `TreeMap` jne. ## Comparator — ulkoiset järjestykset (monia, määritelty erikseen) ```java // define orderings OUTSIDE the class — as many as you need Comparator byName = (a, b) -> a.getName().compareTo(b.getName()); Comparator byAge = Comparator.comparingInt(Person::getAge); people.sort(byName); // sort by name people.sort(byAge.reversed()); // by age, descending ``` `Comparator` on erillinen objekti, jonka avulla voit määrittää **useita** eri järjestyksiä samalle luokalle ilman sen muuttamista. ## Moderni, sujuva Comparator API ```java Comparator 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); ``` Konstruktori-tyylisten `comparing`/`thenComparing`-metodien ansiosta monimutkainen monten kenttien järjestäminen on ytimekästä ja luettavaa. ## Milloin käyttää mitäkin ```text 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) ``` ## Miksi se on tärkeää Objektien järjestäminen on jatkuva tarve — listojen lajittelu, `TreeSet`/`TreeMap`-käyttö, min/max-etsintä. Comparable-ja Comparator-eron ymmärtäminen antaa sinulle mahdollisuuden valita oikein: `Comparable` luokan yksittäiselle luontaiselle järjestykselle (sisäänrakennettu, käytetään oletuksena), `Comparator` useiden tai ulkoisten järjestysten joustavuudelle (lajittele samat tiedot eri kenttien mukaan, tai järjestä tyyppejä, joita et hallitse). Moderni sujuva `Comparator` API (`comparing`/`thenComparing`/`reversed`) tekee monista tasoisesta lajittelusta eleganttia. Molemmat hallitseminen — ja tietäminen, milloin kumpi sopii — on välttämätöntä järjestettyjen tietorakenteiden kanssa työskennellessä ja on usein käytännöllinen ja haastattelu-aihe Javassa.