Wie können Listen oder Arrays sortiert werden, deren Inhalt aus Objekten selbst deklarierter Typen bestehen?

Möchte man irgendeine Menge an Elementen sortieren, so muss zunächst definiert werden, was die Kriterien zur Sortierung sind. Das mag bei Zahlen und möglicherweise auch Buchstaben relativ klar sein. Was aber, wenn die zu sortierenden Objekte ganz anderer Natur sind? Die Lösung besteht darin, die Sortierkriterien anhand einer Eigenschaft selbst festzulegen.

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.