Comparable Interface

[ComparableI]

Hi,

geben sind die folgenden Klassen:

public class Human {
	public String name;
	public int weight;
	public Occupation occupation;
}

und

public class Occupation {
	public String name;
	public double salary;
}

Man soll nun beide Klassen so verändern, dass eine Liste von

Human

mit

Collections.sort()

sortiert werden und zwar einmal aufsteigend nach dem

salary

des Berufs eines Menschen und einmal absteigend nach dem

weight

des Menschen.

Mein Versuch:

public class Occupation implements Comparable<Occupation> {

	public String name;
	public double salary;

	@Override
	public int compareTo(Occupation o) {
		if (o == null)
			throw new NullPointerException("Passed argument is null.");

		if (this.salary == o.salary)
			return 0;
		else if (this.salary < o.salary)
			return -1;
		else
			return 1;
	}

}

public class Human implements Comparable<Human> {

	public String name;
	public int weight;
	public Occupation occupation;

	@Override
	public int compareTo(Human human) {
		if (human == null)
			throw new NullPointerException("Nullobjekt übergeben.");

		if (this.weight == human.weight)
			return 0;
		else if (this.weight > human.weight)
			return -1;
		else
			return 1;
	}
}

Mein Problem ist nun folgendes. Wenn ich eine Testklasse schreibe und

Collections.sort

aufrufe, wird nur nach

size

sortiert.

Das ist mein Code und die Ausgabe unten.

package klausur;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class HumanTest {

	public static void main(String[] argv) {

		List<Human> humans = new ArrayList<Human>();

		Human human = new Human();
		human.name = "Eike";
		Occupation occupation = new Occupation();
		occupation.name = "Beruf 1";
		occupation.salary = 45000;
		human.occupation = occupation;
		human.weight = 88;

		humans.add(human);

		human = new Human();
		human.name = "Dirk";
		occupation = new Occupation();
		occupation.name = "Beruf 2";
		occupation.salary = 35000;
		human.occupation = occupation;
		human.weight = 72;

		humans.add(human);

		human = new Human();
		human.name = "Andrea";
		occupation = new Occupation();
		occupation.name = "Beruf 3";
		occupation.salary = 40000;
		human.occupation = occupation;
		human.weight = 59;

		humans.add(human);

		human = new Human();
		human.name = "Arne";
		occupation = new Occupation();
		occupation.name = "Beruf 4";
		occupation.salary = 82000;
		human.occupation = occupation;
		human.weight = 88;

		humans.add(human);

		human = new Human();
		human.name = "Minka";
		occupation = new Occupation();
		occupation.name = "Beruf 5";
		occupation.salary = 54000;
		human.occupation = occupation;
		human.weight = 88;

		humans.add(human);

		for (Human p : humans)
			System.out.println(p.name + "\t" + p.occupation.name + "\t"
					+ p.occupation.salary + "\t" + p.weight);

		Collections.sort(humans);

		System.out.println("\nNun sortiert:\n");

		for (Human p : humans)
			System.out.println(p.name + "\t" + p.occupation.name + "\t"
					+ p.occupation.salary + "\t" + p.weight);

	}

}

Ausgabe:

Eike Beruf 1 45000.0 88
Dirk Beruf 2 35000.0 72
Andrea Beruf 3 40000.0 59
Arne Beruf 4 82000.0 88
Minka Beruf 5 54000.0 88

Nun sortiert:

Eike Beruf 1 45000.0 88
Arne Beruf 4 82000.0 88
Minka Beruf 5 54000.0 88
Dirk Beruf 2 35000.0 72
Andrea Beruf 3 40000.0 59

Frage: Wie bekomme ich denn eine Sortierung aufsteigend nach

salary

nun hin, so wie es verlangt ist? Ich darf nur das Interface

Comparable

verwenden.

 

[Gast2]

Wenn du unterschiedliche Sortierungen haben willst brauchst du Comparator, für jede Sortierung einen. Also einen SalaryComparator und einen WeightComparator.

Diesen Comparator kannst du dann der sort Methode übergeben.

Collections.sort(humans, new SalaryComparator());

 

[nillehammer]

    @Override
    public int compareTo(Human human) {
        if (human == null)
            throw new NullPointerException("Nullobjekt übergeben.");
 
        if (this.weight == human.weight)
            return 0;
        else if (this.weight > human.weight)
            return -1;
        else
            return 1;
    }

Du bist selsbt Schuld. In der compareTo-Methode von Human berücksichtigst Du die salary seiner Occupation garnicht. Schreibe sie so um:

    @Override
    public int compareTo(Human human) {
        if (human == null)
            throw new NullPointerException("Nullobjekt übergeben.");

        final int salaryRestult = this.occupation.compareTo(human.occupation);

        // Wenn  die Salaries unterschiedlich sind, biste fertig. Returne das Ergebnis
        if (salaryResult != 0) {

          return salaryResult;
        }
 
        // Nur, wenn die Salaries gleich sind, ist die Auswertung des zweiten Sortierkriteriums
        // nötig:
        if (this.weight == human.weight)
            return 0;
        else if (this.weight > human.weight)
            return -1;
        else
            return 1;
    }

[EDIT]

Man soll nun beide Klassen so verändern, dass eine Liste von Human mit Collections.sort() sortiert werden und zwar einmal aufsteigend nach dem salary des Berufs eines Menschen und einmal absteigend nach dem weight des Menschen.

Die Formulierung ist recht unglücklich, weil sie die unabhängige Sortierung nach den genannten Kriterien nahelegt. Der Constraint "verwende Comparable" lässt dieses aber nicht zu, da man ja nur eine compareTo-Methode haben kann, die halt irgendwie auch nur eine Sortierreihenfolge ergeben kann. Insofern verstehe ich die Aufgabe so: Implementiere eine sortierung zunächst nach Salary (aufsteigend) und dann nach weight (absteigend). Auf dieser Annahme basiert meine Antwort.

Zur Möglichkeit der Definition verschiedener unabhängiger Sortierkriterien siehe EikeB's Post.
[/EDIT]
[EDIT]Habe meine Antwort nach SlaterB's Hinweis korrigiert (hatte erst nicht so genau gelesen und Salary statt "Salary seiner Occupation" geschrieben.[/EDIT]

 

[SlaterB]

> Mein Problem ist nun folgendes. Wenn ich eine Testklasse schreibe und Collections.sort aufrufe, wird nur nach size sortiert.

'size' taucht in deinem Posting sonst nirgendwo auf, du meinst wohl weight,

in compareTo(Human human) musst du als erstes die beiden occupation-Objekte vergleichen, deren compareTo() nutzen

edit:
> In der compareTo-Methode von Human berücksichtigst Du seine Salary garnicht.

oh, bisschen ungenau, Human hat kein salary

edit2:
wenn wirklich nach beiden Kriterien sortiert werden soll, wäre es wäre sinnvolll, nicht nur unterschiedliche Gehälter in den Testobjekten zu haben

 

[nillehammer]

edit:
> In der compareTo-Methode von Human berücksichtigst Du seine Salary garnicht.

oh, bisschen ungenau, Human hat kein salary

Hab' gerade per Edit-Funktion in meiner Anwort korrigiert.

 

[ComparableI]

An den

Comparator

dachte ich auch, ist ja klar. Ich verstehe die Aufgabe so, dass nach dem Gehalt zuerst sortiert wird und bei Gleichheit nach der Größe.

Bei der Umsetzung hapert es.

 

[Gast2]

Ich verstehe die Aufgabe so, dass nach dem Gehalt zuerst sortiert wird und bei Gleichheit nach der Größe.

Dann helfen dir die Hinweise von SlaterB und nillehammer.

 

[Christiano]

Hi,

du kannst die 2 Kriterien folgendermassen einnisten:

* *public int compareTo(Human human){
* * * *
* * * *if (human == null)
* * * * * *throw new NullPointerException ("passed argument is null.");
* * * *
* *
* * * *if (this.occupation.salary==human.occupation.salary) * *
* * * * * *
* * * * * *if (this.weight == human.weight)
* * * * * * * *
* * * * * * * *return 0;
* * * *
* * * * * *else if *(this.weight < human.weight)
* * * * * * * *return 1;
* * * * * *
* * * * * *else return -1;
* *
* * * *else if (this.occupation.salary<human.occupation.salary) * *
* * * * return -1;
* * * *
* * * *else return 1;
* * * *
* *}

 

[bygones]

@Christiano.

nette * aber fuer code gibts - wie der nette rote dicke Hinweis es sagt - die [ java ] tags....