Trier les objets dans ArrayList par date?

Chaque exemple que je trouve consiste à faire cela par ordre alphabétique, alors que j'ai besoin de mes éléments triés par date.

My ArrayList contient des objets sur lesquels l'un des datamembers est un objet DateTime. Sur DateTime, je peux appeler les fonctions:

lt() // less-than
lteq() // less-than-or-equal-to

Donc, pour comparer, je pourrais faire quelque chose comme:

if(myList.get(i).lt(myList.get(j))){
    // ...
}

Que dois-je faire à l'intérieur du bloc if?

Vous pouvez rendre votre objet comparable:

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    return getDateTime().compareTo(o.getDateTime());
  }
}

Et puis vous le triez en appelant:

Collections.sort(myList);

Cependant, parfois, vous ne souhaitez pas modifier votre modèle, comme lorsque vous souhaitez trier sur plusieurs propriétés différentes. Dans ce cas, vous pouvez créer un comparateur à la volée:

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

Cependant, ce qui précède ne fonctionne que si vous êtes certain que dateTime n'est pas nul au moment de la comparaison. Il est sage de gérer également null pour éviter les NullPointerExceptions:

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    if (getDateTime() == null || o.getDateTime() == null)
      return 0;
    return getDateTime().compareTo(o.getDateTime());
  }
}

Ou dans le deuxième exemple:

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      if (o1.getDateTime() == null || o2.getDateTime() == null)
        return 0;
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

Depuis Java 8, l' interface List fournit la méthode de tri . Combinée à l' expression lambda , la solution la plus simple serait

// sort DateTime typed list
list.sort((d1,d2) -> d1.compareTo(d2));
// or an object which has an DateTime attribute
list.sort((o1,o2) -> o1.getDateTime().compareTo(o2.getDateTime()));
// or like mentioned by Tunaki
list.sort(Comparator.comparing(o -> o.getDateTime()));

Tri inversé

Java 8 est également fourni avec des méthodes pratiques pour le tri inversé.

//requested by lily
list.sort(Comparator.comparing(o -> o.getDateTime()).reversed());

Vous pouvez utiliser la méthode Collections.sort. C'est une méthode statique. Vous lui passez la liste et un comparateur. Il utilise un algorithme de tri de fusion modifié sur la liste. C'est pourquoi vous devez lui passer un comparateur pour faire les comparaisons de paires.

Collections.sort(myList, new Comparator<MyObject> {
   public int compare(MyObject o1, MyObject o2) {
      DateTime a = o1.getDateTime();
      DateTime b = o2.getDateTime();
      if (a.lt(b)) 
        return -1;
      else if (a.lteq(b)) // it's equals
         return 0;
      else
         return 1;
   }
});

Notez que si myList est d'un type comparable (celui qui implémente l'interface Comparable) (comme Date, Integer ou String), vous pouvez omettre le comparateur et l'ordre naturel sera utilisé.

list.sort(Comparator.comparing(o -> o.getDateTime()));

La meilleure réponse à mon humble avis de Tunaki en utilisant Java 8 lambda

Étant donné MyObjectqu'il a un DateTimemembre avec une getDateTime()méthode, vous pouvez trier un ArrayListqui contient des MyObjectéléments par les DateTimeobjets comme ceci:

Collections.sort(myList, new Comparator<MyObject>() {
    public int compare(MyObject o1, MyObject o2) {
        return o1.getDateTime().lt(o2.getDateTime()) ? -1 : 1;
    }
});

Voici comment j'ai résolu:

Collections.sort(MyList, (o1, o2) -> o1.getLastModified().compareTo(o2.getLastModified()));

J'espère que cela vous aidera.

Avec l'introduction de Java 1.8, les flux sont très utiles pour résoudre ce genre de problèmes:

Comparator <DateTime> myComparator = (arg1, arg2) 
                -> {
                    if(arg1.lt(arg2)) 
                       return -1;
                    else if (arg1.lteq(arg2))
                       return 0;
                    else
                       return 1;
                   };

ArrayList<DateTime> sortedList = myList
                   .stream()
                   .sorted(myComparator)
                   .collect(Collectors.toCollection(ArrayList::new));

Toutes les réponses que j'ai trouvées ici sont inutilement complexes pour un problème simple (du moins pour un développeur Java expérimenté, ce que je ne suis pas). J'ai eu un problème similaire et je suis tombé sur cette solution (et d'autres), et bien qu'elles aient fourni un pointeur, pour un débutant, j'ai trouvé comme indiqué ci-dessus. Ma solution dépend de l'emplacement de l'objet de votre date, dans ce cas, la date est le premier élément de l'objet [] où dataVector est le ArrayList contenant vos objets.

Collections.sort(dataVector, new Comparator<Object[]>() {
    public int compare(Object[] o1, Object[] o2) {
        return ((Date)o1[0]).compareTo(((Date)o2[0]));
    }
});

Cela peut être une ancienne réponse mais j'ai utilisé quelques exemples de ce poste pour créer un comparateur qui trierait un ArrayListde HashMap<String, String>par un objet dans la liste, qui étant l'horodatage.

J'ai ces objets:

ArrayList<Map<String, String>> alList = new ArrayList<Map<String, String>>();

Les objets cartographiques sont les suivants:

Map<String, Object> map = new HashMap<>();
        // of course this is the actual formatted date below in the timestamp
        map.put("timestamp", "MM/dd/yyyy HH:mm:ss"); 
        map.put("item1", "my text goes here");
        map.put("item2", "my text goes here");

Ce mappage est ce que j'utilise pour charger tous mes objets dans la liste de tableaux, en utilisant la alList.add(map)fonction, dans une boucle.

Maintenant, j'ai créé mon propre comparateur:

import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

 public class DateSorter implements Comparator {
     public int compare(Object firstObjToCompare, Object secondObjToCompare) {
    String firstDateString = ((HashMap<String, String>) firstObjToCompare).get("timestamp");
    String secondDateString = ((HashMap<String, String>) secondObjToCompare).get("timestamp");

    if (secondDateString == null || firstDateString == null) {
        return 0;
    }

    // Convert to Dates
    DateTimeFormatter dtf = DateTimeFormat.forPattern("MM/dd/yyyy HH:mm:ss");
    DateTime firstDate = dtf.parseDateTime(firstDateString);
    DateTime secondDate = dtf.parseDateTime(secondDateString);

    if (firstDate.isAfter(secondDate)) return -1;
    else if (firstDate.isBefore(secondDate)) return 1;
    else return 0;
    }
}

Je peux maintenant simplement appeler le comparateur à tout moment sur le tableau et il triera mon tableau, me donnant le dernier horodatage en position 0 (en haut de la liste) et le premier horodatage à la fin de la liste. Les nouveaux messages sont mis au sommet essentiellement.

Collections.sort(alList, new DateSorter());

Cela peut aider quelqu'un, c'est pourquoi je l'ai publié. Prenez en considération les instructions de retour dans la fonction compare (). Il existe 3 types de résultats. Renvoie 0 s'ils sont égaux, renvoie> 0 si la première date est antérieure à la deuxième date et renvoie <0 si la première date est postérieure à la deuxième. Si vous voulez que votre liste soit inversée, changez simplement ces deux instructions de retour! Simple =]

Passez l'argument ArrayList In.

    private static void order(ArrayList<Object> list) {

    Collections.sort(list, new Comparator() {

        public int compare(Object o2, Object o1) {

            String x1 =  o1.Date;
            String x2 =  o2.Date;

                return  x1.compareTo(x2);

        }
    });
}

Utilisez l'approche ci-dessous pour identifier les dates triées ou non

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy");

boolean  decendingOrder = true;
    for(int index=0;index<date.size() - 1; index++) {
        if(simpleDateFormat.parse(date.get(index)).getTime() < simpleDateFormat.parse(date.get(index+1)).getTime()) {
            decendingOrder = false;
            break;
        }
    }
    if(decendingOrder) {
        System.out.println("Date are in Decending Order");
    }else {
        System.out.println("Date not in Decending Order");
    }       
}   

La classe Date implémente déjà l'interface Comparator. En supposant que vous ayez la classe ci-dessous:

public class A {

    private Date dateTime;

    public Date getDateTime() {
        return dateTime;
    }

    .... other variables

}

Et disons que vous avez une liste d'objets A List<A> aList, vous pouvez facilement la trier avec l'API de flux de Java 8 (extrait ci-dessous):

import java.util.Comparator;
import java.util.stream.Collectors;

...

aList = aList.stream()
        .sorted(Comparator.comparing(A::getDateTime))
        .collect(Collectors.toList())

Futurs téléspectateurs, je pense que c'est la solution la plus simple, si votre modèle contient une chaîne de type date ("2020-01-01 10:00:00" par exemple), alors écrivez simplement la ligne suivante pour trier les données par date décroissant de du plus récent au plus ancien:

Collections.sort(messages, (o1, o2) -> o2.getMessageDate().compareTo(o1.getMessageDate()));