Comment trier la liste d'objets par une propriété

Question

J'ai cours simple

 public class ActiveAlarm {
    public long timeStarted;
    public long timeEnded;
    private String name = "";
    private String description = "";
    private String event;
    private boolean live = false;
}
 

et liste con. Comment trier par ordre chronologique, puis par heure terminée? Quelqu'un peut aider? Je connais en C ++ avec un algorithme générique et un opérateur de surcharge <, mais je suis nouveau en Java.

Answer 1

Utilisation de Comparator

Par exemple:

 class Score {

    private String name;
    private List<Integer> scores;
    // +accessor methods
}
 

---

     Collections.sort(scores, new Comparator<Score>() {

        public int compare(Score o1, Score o2) {
            return o2.getScores().get(0).compareTo(o1.getScores().get(0));
        }
    });
 

Answer 2

Faites-en ActiveAlarm œuvre Comparable<ActiveAlarm> ou de mettre en oeuvre Comparator<ActiveAlarm> dans une catégorie distincte. Ensuite, composez le:

Collections.sort(list);

ou

Collections.sort(list, comparator);

En général, c'est une bonne idée à mettre en oeuvre Comparable<T> si il y a un seul "naturel" de l'ordre de tri... dans le cas contraire (si vous arriver de vouloir trier dans un ordre particulier, mais pourrait tout aussi facilement veux un autre) il est préférable de mettre en oeuvre Comparator<T>. Cette situation particulière pourrait aller de toute façon, pour être honnête... mais je serais probablement rester avec le plus flexible Comparator<T> option.

EDIT: Exemple de mise en œuvre:

public class AlarmByTimesComparer implements Comparator<ActiveAlarm> {
  @Override
  public int compare(ActiveAlarm x, ActiveAlarm y) {
    // TODO: Handle null x or y values
    int startComparison = compare(x.timeStarted, y.timeStarted);
    return startComparison != 0 ? startComparison
                                : compare(x.timeEnded, y.timeEnded);
  }

  // I don't know why this isn't in Long...
  private static int compare(long a, long b) {
    return a < b ? -1
         : a > b ? 1
         : 0;
  }
}

Answer 3

On peut trier la liste dans l'une des deux façons suivantes:

1. À l'aide du Comparateur : Lorsque requis pour l'utilisation de la logique de tri dans plusieurs endroits Si vous souhaitez utiliser la logique de tri dans un seul endroit, alors vous pouvez écrire un anonyme intérieur de la classe, comme suit, ou encore de l'extrait de la comparaison et de l'utiliser dans de multiples endroits

  Collections.sort(arrayList, new Comparator<ActiveAlarm>() {
        public int compare(ActiveAlarm o1, ActiveAlarm o2) {
            //Sorts by 'TimeStarted' property
            return o1.getTimeStarted()<o2.getTimeStarted()?-1:o1.getTimeStarted()>o2.getTimeStarted()?1:doSecodaryOrderSort(o1,o2);
        }

        //If 'TimeStarted' property is equal sorts by 'TimeEnded' property
        public int doSecodaryOrderSort(ActiveAlarm o1,ActiveAlarm o2) {
            return o1.getTimeEnded()<o2.getTimeEnded()?-1:o1.getTimeEnded()>o2.getTimeEnded()?1:0;
        }
    });

On peut avoir la valeur null vérifier les propriétés, si nous pouvions avoir utilisé "Long" au lieu de "long".

2. À l'aide de Comparable(ordre naturel): Si l'algorithme de tri toujours s'en tenir à une propriété: écrire une classe qui implémente des "Comparables" et remplacer "compareTo" la méthode définie ci-dessous

class ActiveAlarm implements Comparable<ActiveAlarm>{

public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;

public ActiveAlarm(long timeStarted,long timeEnded) {
    this.timeStarted=timeStarted;
    this.timeEnded=timeEnded;
}

public long getTimeStarted() {
    return timeStarted;
}

public long getTimeEnded() {
    return timeEnded;
}

public int compareTo(ActiveAlarm o) {
    return timeStarted<o.getTimeStarted()?-1:timeStarted>o.getTimeStarted()?1:doSecodaryOrderSort(o);
}

public int doSecodaryOrderSort(ActiveAlarm o) {
    return timeEnded<o.getTimeEnded()?-1:timeEnded>o.getTimeEnded()?1:0;
}

}

appel de méthode de tri pour trier naturelle de la commande

Collections.sort(list);

Answer 4

 public class ActiveAlarm implements Comparable<ActiveAlarm> {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;

public int compareTo(ActiveAlarm a) {
    if ( this.timeStarted > a.timeStarted )
        return 1;
    else if ( this.timeStarted < a.timeStarted )
        return -1;
    else {
         if ( this.timeEnded > a.timeEnded )
               return 1;
         else
              return -1;
     }

 }
 

Cela devrait vous donner une idée approximative. Une fois que c'est fait, vous pouvez appeler Collections.sort () sur la liste.

Answer 5

En Java, vous devez utiliser la méthode statique Collections.sort . Voici un exemple de liste d’objets CompanyRole, triés d’abord par début, puis par fin. Vous pouvez facilement vous adapter à votre propre objet.

 private static void order(List<TextComponent> roles) {

    Collections.sort(roles, new Comparator() {
        public int compare(Object o1, Object o2) {

            int x1 = ((CompanyRole) o1).getBegin();
            int x2 = ((CompanyRole) o2).getBegin();

            if (x1 != x2) {
                return x1 - x2;
            } else {
                int y1 = ((CompanyRole) o1).getEnd();
                int y2 = ((CompanyRole) o2).getEnd();
                return y2 - y1;
            }
        }
    });
}
 

La liste va maintenant être triée :)