Sortuj obiekty w ArrayList według daty?

Od Javy 8 Interfejs List dostarcza metodę sort . W połączeniu z wyrażeniem lambda najprostszym rozwiązaniem byłoby

// 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()))

Możesz używać kolekcji.metoda sortowania. To metoda statyczna. Podajesz listę i komparator. Używa zmodyfikowanego algorytmu mergesort nad listą. Dlatego musisz przekazać go komparator, aby zrobić porównania par.

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;
   }
});

Zauważ, że jeśli myList jest porównywalnego typu (takiego, który implementuje porównywalny interfejs) (jak Date, Integer lub String), możesz pominąć komparator i zostanie użyta naturalna kolejność.

Biorąc pod uwagę MyObject, który ma element DateTime z metodą getDateTime(), możesz sortować ArrayList, który zawiera MyObject elementy według DateTime obiektów, takich jak:

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

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

Najlepsza odpowiedź IMHO od Tunaki za pomocą Java 8 lambda

Oto jak rozwiązałem:

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

Wszystkie odpowiedzi, które tu znalazłem, okazały się nie-konieczne do skomplikowania prostego problemu(przynajmniej dla doświadczonego programisty Javy, którym nie jestem). Miałem podobny problem i chased na ten (i inne) rozwiązania, i choć podali wskaźnik, dla początkującego znalazłem jak wspomniano powyżej. Moje rozwiązanie zależy od tego, gdzie w obiekcie znajduje się data, w tym przypadku Data jest pierwszym elementem obiektu [], gdzie dataVector jest ArrayList zawierającym Twoje obiekty.

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

Wraz z wprowadzeniem Javy 1.8, strumienie są bardzo przydatne w rozwiązywaniu tego rodzaju problemów:

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));

DateTime.porównaj ?

To może być stara odpowiedź, ale użyłem kilku przykładów z tego postu, aby utworzyć komparator, który posortowałby ArrayList z HashMap<String, String> według jednego obiektu na liście, czyli znacznika czasu.

Mam te obiekty:

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

Obiekty mapy są następujące:

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");

To mapowanie jest tym, czego używam do załadowania wszystkich moich obiektów do listy tablic, za pomocą funkcji alList.add(map), wewnątrz pętli.

Teraz stworzyłem swój własny komparator:

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;
    }
}

Mogę teraz po prostu zadzwonić do komparatora w dowolnym momencie na tablicy i posortuje moją tablicę, dając mi najnowszy znacznik czasu na pozycji 0 (Góra listy) i najwcześniejszy znacznik czasu na końcu listy. Nowe posty trafiają na szczyt.

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

To może komuś pomóc, dlatego to zamieściłem. Weź pod uwagę polecenia return w funkcji compare (). Istnieją 3 rodzaje wyników. Zwraca 0, jeśli są równe, zwraca >0, Jeśli pierwsza data jest przed drugą datą i zwraca

Podaj ArrayList w argumencie.

    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);

        }
    });
}