Wann Comparator und wann Comparable

[Biesterfeld]

Hej Board,

folgender Fall: Ich sammel eine große Menge Objekte in einem HashSet ein, die ich im weiteren Programmverlauf immerwieder nach verschiedenen Kriterien in einen TreeSet sortieren möchte.

Was ist einem solchen Fall sinnvoll, sie zusammen mit einem Comparator dem TreeSet zu übergeben, oder Comparable in der Klasse zu implementieren und ... ja und weiß gar nicht, kann ich überhaupt dann noch nach je nach Anfrage nach verschiedenen Kriterien sortieren? Also eigentlich dachte ich mir, dass Comparable da eher geschickt ist, oder überseh ich da ein feature?

Und dann noch ne Frage: Was ist eleganter? Für jedes Kriterium einen eigenen Comparator schreiben, oder die unterschiedlichen Sortierkriterien in einem Comparator implementieren und diesen entsprechend Aufrufen, also

new TreeSet(collection, new CompareObject("CRITERION_1"));

public class CompareObject implements Comparator{
  
  private final String criterion;
  
  CompareObject(String criterion){
    this.criterion = criterion;
  }
  
  public int compare(Object arg0, Object arg1){
     if(criterion.equals("CRITERION_1"))
       return compareByC1(Object arg0, Object arg1);
     else
        return compareByC2(Object arg0, Object arg1);
  }

  private int compareByC1(Object arg0, Object arg1){
     ...
  }

  private int compareByC2(Object arg0, Object arg1){
     ...
  }
  
}

Danke schonmal für eure Hilfe.
Beste Grüße
Biesterfeld

 

[Bert Brenner]

Einen Comparator verwende ich auf Klassen die Comparable nicht implementieren oder deren Comparable implementation für meine Zwecke nicht geeignet sind.

Ich glaub (als Java halbkönner ) genau dafür ist der Comparator auch vorgesehen, werde aber auch mal schaun was die Gurus dazu sagen.

 

[mic_checker]

http://jforum.de/showpost.php?p=5351&postcount=13

Ansonsten hatten wir schon einige Threads zum Thema "Comparable".

Wenn du unterschiedlich sortieren willst, würde ich vorschlagen Comparator zu verwenden.

 

[Guest]

Am besten eine Kombination aus beiden.
Ich mache es oft wie folgt:

class Person implements Comparable {
  private Integer id;
  private String firstname; 
  private Sring lastname;

  ...

  public int compareTo(Object o) {
    return PersonComparator.ASC_BY_ID.compare(this, (Person)o);
  }
}

final class PersonComparator implements Comparator {
  public static final PersonComparator ASC_BY_ID = new PersonComparator(0, true);
  public static final PersonComparator ASC_BY_FIRSTNAME = new PersonComparator(1, true);
  public static final PersonComparator ASC_BY_LASTNAME = new PersonComparator(2, true);
  public static final PersonComparator DESC_BY_ID = new PersonComparator(0, false);
  public static final PersonComparator DESC_BY_FIRSTNAME = new PersonComparator(1, false);
  public static final PersonComparator DESC_BY_LASTNAME = new PersonComparator(2, false);

  private int sortorder;
  private boolean ascending;

  private PersonComparator(int sortorder, boolean ascending) {
    this.sortorder = sortorder;
    this.ascending = ascending;
  }

  public int compare(Object o1, Object o2) {
    Person p1 = (Person)(ascending?o1:o2);
    Person p2 = (Person)(ascending?o2:o1);
    switch(sortorder) {
      case 0: return p1.id.compareTo(p2.id);
      case 1: return p1.firstname.compareTo(p2.firstname);
      case 2: return p1.lastname.compareTo(p2.lastname);
    }
    return 0; // to make the compiler happy
  }
}

Die Haupteigenschaft bzw. das häufigste Attribut der Klasse wird als Defaul bei Comparable verwendet,
alles andere optional, um mal eine Collection solcher Objekte nach anderen Kriterien zu sortieren.
z.B.

Collection personen = connector.getPersonenByWhatever(...);
Collections.sort(personen, PersonComparator.DESC_BY_LASTNAME);

 

[Guest]

Korrektur (unnötiger cast)

class Person implements Comparable { 
  private Integer id; 
  private String firstname; 
  private Sring lastname; 

  ... 

  public int compareTo(Object o) { 
    return PersonComparator.ASC_BY_ID.compare(this, o); 
  } 
}

 

[Guest]

Ehmm, und wo wir schon bei Fehlern sind :roll:

public int compare(Object o1, Object o2) { 
  Person p1 = (Person)(ascending?o1:o2); 
  Person p2 = (Person)(ascending?o2:o1); 
  switch(sortorder) { 
    case 0: return p1.getId().compareTo(p2.getId()); 
    case 1: return p1.getFirstname().compareTo(p2.getFirstname()); 
    case 2: return p1.getLastname().compareTo(p2.getLastname()); 
  } 
  return 0; // to make the compiler happy 
}

OK, jetzt aber. :wink:

 

[Biesterfeld]

Hej,

dank euch für die Antworten. Ich hatte natürlich nach "Comparator Comparable" (is ja doof dass sich Suchergebnisse nicht verlinken lassen) gesucht gehabt aber nicht wirklich viel dazu gefunden. ???:L

Aber das war schon sehr hilfreich, insbesondere die Anwtort von dem Gast war sehr, sehr geil. Werds wohl so machen, nur dass ich mir die Implementierung von Comparable sparen werde.

Dank euch ganz herzlich und wünsche ein frohes Osterfest.
Beste Grüße
Biesterfeld