Comparable und Comparator nicht ganz klar

[Maik.Neumann]

Juten Tach,

ich habe hier zwei Beispiele zum Sortieren von Objekten gefunden, deren UNterschied mir noch nicht ganz klar ist. Das erste Beispiel ist heir aufgeführt:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Usage:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

Hier ist das zweite Beispiel und hier wird explizit mit 0, 1 und -1 als möglichen Rückgabewerten gearbeitet:

public class Bier {
 
  private String name;
  private String herkunft;
  private float inhalt;
 
  public Bier() {}
 
  public Bier(String name, String herkunft, float inhalt) {
 
    this.name = name;
    this.herkunft = herkunft;
    this.inhalt = inhalt;
  }
 
  public String getName() {
    return this.name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public String getHerkunft() {
    return this.herkunft;
  }
 
  public void setHerkunft(String herkunft) {
    this.herkunft = herkunft;
  }
 
  public float getInhalt() {
    return this.inhalt;
  }
 
  public void setInhalt(float inhalt) {
    this.inhalt = inhalt;
  }
 
  public String toString() {
    return this.name + " aus " + this.herkunft + " mit " + this.inhalt + " Litern";
  }
}

public class Bier implements Comparable<Bier> {
 
  ...
 
  @Override
  public int compareTo(Bier b) {
    if (b.getName() == null && this.getName() == null) {
      return 0;
    }
    if (this.getName() == null) {
      return 1;
    }
    if (b.getName() == null) {
      return -1;
    }
    return this.getName().compareTo(b.getName());
  }
}

public class BierNameComparator implements Comparator<Bier> {
 
  @Override
  public int compare(Bier b1, Bier b2) {
    if (b1.getName() == null && b2.getName() == null) {
      return 0;
    }
    if (b1.getName() == null) {
      return 1;
    }
    if (b2.getName() == null) {
      return -1;
    }
    return b1.getName().compareTo(b2.getName());
  }
}

public class ArraysAndCollectionsTest {
 
  public static void main(String[] args) {
 
    Comparator<Bier> comp = new BierComparator();
    Bier[] biere = {
        new Bier("Würzburger Hofbräu", "Würzburg", 0.5F),
        new Bier("Becks", "Bremen", 0.33F),
        new Bier("Paulaner", "München", 0.5F),
        new Bier("Distelhäuser", "Distelhausen", 0.33F) };
    System.out.println("Unsortiert:");
    System.out.println("-----------");
    for (Bier bier : biere) {
      System.out.println(bier);
    }
    Arrays.sort(biere, comp);
    System.out.println("Sortiert:");
    System.out.println("-----------");
    for (Bier bier : biere) {
      System.out.println(bier);
    }
  }
}

Warum arbeitet das erste Beispiele ohne explizite Rückgabewerte ud das zweite explizit mit 0, 1 und -1.

Kann es u.U. sein, dass in dem ersten Beispiel als Ergebnis durch die Berechnung einfach nur ein positiver oder negativer Wert zurückgegeben wird (oder auch die 0), der allerdings deutlich größer sein kann als 1 oder -1 und daran einfach die Sortierung vorgenommen wird?

Das ist das vielleicht schon der gesamte Unterschied?

Beste Grüße
Maik

 

[diggaa1984]

Kann es u.U. sein, dass in dem ersten Beispiel als Ergebnis durch die Berechnung einfach nur ein positiver oder negativer Wert zurückgegeben wird (oder auch die 0), der allerdings deutlich größer sein kann als 1 oder -1 und daran einfach die Sortierung vorgenommen wird?

Ein Blick in die Doku bingt folgendes zum Vorschein:
Comparable#compareTo

Returns:
a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Comparator#compare

Returns:
a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

So gesehen, hast du Recht