Wie können Listen oder Arrays sortiert werden, deren Inhalt aus Objekten selbst deklarierter Typen bestehen?
In Java kann dies durch das Interface Comparable erfolgen.
Es muss von der Klasse der zu sortierenden Elemente implementiert
werden. Seine Methode public int compareTo(Object o)
übernimmt dann die Definition der Vergleichskriterien.
Im
Beispiel ist eine Klasse Moped deklariert, die
Motorradtypen anhand des Namens, Modells und der Leistung definiert.
Die Eigenschaften werden in entsprechenden Instanzvariablen
gespeichert.
In der Methode compareTo(Object m) wird
in diesem Fall der Hersteller des aktuellen Moped-Objektes
mit einem zweiten verglichen. Hierbei ist die Regelung die folgende:
Ist
das aktuelle Objekt das übergeordnete, wird ein positiver Wert
zurück gegeben, ist das als Parameter übergebene Objekt
das übergeordnete, wird ein negativer Wert zurück gegeben
und sind die Vergleichsdaten identisch, wird 0 zurück gegeben.
Hierbei greift die Methode auf die gleichnamige Methode der Klasse String
zurück, die diese durch die Implementierung von Comparable
ebenfalls enthält.
import java.util.Arrays;
public class ObjectVergleich {
public static void main(String[] args) {
Moped m1 = new Moped("BMW", "R1100S", 98);
System.out.println("m1: " + m1.getHersteller());
Moped m2 = new Moped("AJS", "7R", 45);
System.out.println("m2: " + m2.getHersteller());
Moped m3 = new Moped("Moto Guzzi", "V8", 72);
System.out.println("m3: " + m3.getHersteller());
Moped m4 = new Moped("Böhmerland", "600ccm", 16);
System.out.println("m4: " + m4.getHersteller());
Moped[] moped = { m1, m2, m3, m4 };
Arrays.sort(moped);
for (int i = 0; i < moped.length; i++) {
System.out.println(moped[i].getHersteller());
}
}
}
class Moped implements Comparable<Object> {
String hersteller;
String typ;
int ps;
public Moped(String hersteller, String typ, int ps) {
this.hersteller = hersteller;
this.typ = typ;
this.ps = ps;
}
public int compareTo(Object m) {
if (((Moped) m).getHersteller() == null && this.getHersteller() == null) {
return 0;
}
if (this.getHersteller() == null) {
return 1;
}
if (((Moped) m).getHersteller() == null) {
return -1;
}
return this.getHersteller().compareTo(((Moped) m).getHersteller());
}
public String getHersteller() {
return hersteller;
}
public String getTyp() {
return typ;
}
public int getPS() {
return ps;
}
}
Sollen die Leistungen der Motorräder aufsteigend verglichen werden, so muss nur die Differenz beider PS-Werte gebildet werden:
public int compareTo(Object m) { if (((Moped) m).getPS() == 0 && this.getPS() == 0) { return 0; } if (this.getPS() == 0) { return -1; } if (((Moped) m).getPS() == 0) { return 1; } return this.getPS() - ((Moped) m).getPS(); }
In der main-Methode kann man dann sehen wie das funktioniert: Nach der Bildung der Objekte werden diese in einem Array abgelegt, das dann auf die übliche Weise mit der statischen Methode Arrays.sort() sortiert werden kann. Hierbei greift der Sortiermechanismus auf die in compareTo() selbst definierten Kriterien zurück.