Sort objects in ArrayList by date?

Since Java 8 the List interface provides the sort method. Combined with lambda expression the easiest solution would be

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

Reverse sorting

Java 8 comes also with some handy methods for reverse sorting.

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

You can use Collections.sort method. It's a static method. You pass it the list and a comparator. It uses a modified mergesort algorithm over the list. That's why you must pass it a comparator to do the pair comparisons.

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

Note that if myList is of a comparable type (one that implements Comparable interface) (like Date, Integer or String) you can omit the comparator and the natural ordering will be used.

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

The best answer IMHO from Tunaki using Java 8 lambda

Given MyObject that has a DateTime member with a getDateTime() method, you can sort an ArrayList that contains MyObject elements by the DateTime objects like this:

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

Here's the answer of how I achieve it:

Mylist.sort(Comparator.comparing(myClass::getStarttime));

This is how I solved:

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

Hope it help you.

Future viewers, I think this is the simplest solution, if your model contains a string type date ("2020-01-01 10:00:00" for example), then just write the following line to sort the data by date descending from newest to the oldest:

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

All the answers here I found to be un-neccesarily complex for a simple problem (at least to an experienced java developer, which I am not). I had a similar problem and chanced upon this (and other) solutions, and though they provided a pointer, for a beginner I found as stated above. My solution, depends on where in the the Object your Date is, in this case, the date is the first element of the Object[] where dataVector is the ArrayList containing your Objects.

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

With introduction of Java 1.8, streams are very useful in solving this kind of problems:

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

This may be an old response but I used some examples from this post to create a comparator that would sort an ArrayList of HashMap<String, String> by one object in the list, that being the timestamp.

I have these objects:

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

The map objects are as follows:

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

That mapping is what I use to load all my objects into the array list, using the alList.add(map) function, within a loop.

Now, I created my own comparator:

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

I can now just call the Comparator at any time on the array and it will sort my array, giving me the Latest timestamp in position 0 (top of the list) and the earliest timestamp at the end of the list. New posts get put to the top basically.

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

This may help someone out, which is why I posted it. Take into consideration the return statements within the compare() function. There are 3 types of results. Returning 0 if they are equal, returning >0 if the first date is before the second date and returning <0 if the first date is after the second date. If you want your list to be reversed, then just switch those two return statements! Simple =]

Use the below approach to identify dates are sort or not

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

The Date class already implements Comparator interface. Assuming you have the class below:

public class A {

    private Date dateTime;

    public Date getDateTime() {
        return dateTime;
    }

    .... other variables

}

And let's say you have a list of A objects as List<A> aList, you can easily sort it with Java 8's stream API (snippet below):

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

...

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

tl;dr

Sort the List by specifying a Comparator.

record Employee ( String name , LocalDate hired ) {}
List < Employee > employees = new ArrayList<>() ;
…
employees.sort
(
            Comparator
                    .comparing( Employee :: hired )
                    .thenComparing( Employee :: name );
);

Or, build the Comparator into the class, implementing Comparable, then tell the List to sort by natural order.

public record Employee( String name , LocalDate hired )
        implements Comparable < Employee >
{
    private static final Comparator < Employee > COMPARATOR =
            Comparator
                    .comparing( Employee :: hired )
                    .thenComparing( Employee :: name );

    @Override
    public int compareTo ( final Employee other )
    {
        return Employee.COMPARATOR.compare( this , other );
    }
}
List < Employee > employees = new ArrayList<>() ;
……
employees.sort() ;

Or, replace that List with a SequencedSet like TreeSet that auto-sorts as you add.

SequencedSet < Employee > seniority = new TreeSet<>() ;

java.time

You said:

one of the datamembers is a DateTime object

Java has no DateTime class. For date-time types, use the java.time classes built into Java 8+.

For a date-only value (year-month-day), use java.time.LocalDate class.

Records

If the main purpose of your class is to transparently communicate shallowly-immutable data, define it as a record.

record Employee ( String name , LocalDate hired ) {}

Sequenced Collections

Java 21 brought sequenced collections. See JEP 431 and video.

SequencedCollection is a super-interface of List and therefore ArrayList.

List#sort

Now you could just call List#sort. Pass a Comparator object to specify how to sort.

List < Employee > employees =
        new ArrayList <>(
                List.of(
                        new Employee( "Alice" , LocalDate.of( 2022 , Month.JANUARY , 23 ) ) ,
                        new Employee( "Bob" , LocalDate.of( 2019 , Month.JANUARY , 23 ) ) ,
                        new Employee( "Carol" , LocalDate.of( 2018 , Month.JANUARY , 23 ) ) ,
                        new Employee( "Davis" , LocalDate.of( 2025 , Month.JANUARY , 23 ) )
                )
        );

employees.sort
(
            Comparator
                    .comparing( Employee :: hired )
                    .thenComparing( Employee :: name );
);

Natural order

We can make that comparator a built-in part of our class. Then objects of our class would know how to sort themselves by implementing the Comparable interface.

public record Employee( String name , LocalDate hired )
        implements Comparable < Employee >
{
    private static final Comparator < Employee > COMPARATOR =
            Comparator
                    .comparing( Employee :: hired )
                    .thenComparing( Employee :: name );

    @Override
    public int compareTo ( final Employee other )
    {
        return Employee.COMPARATOR.compare( this , other );
    }
}

Being able to sort themselves is called “natural order”.

SequencedSet

But instead of sorting your list, I would suggest using a collection that automatically sorts your objects as you add them.

For that collection, I suggest a SequencedCollection that is a SequencedSet, such as TreeSet.

Pass your existing list to the constructor of a TreeSet, a SequencedSet, to automatically sort themselves. Since our Employee objects implement Comparable, we need not specify any Comparator.

SequencedCollection < Employee > seniority = new TreeSet <>( employees );

Dump to console.

seniority.forEach( IO :: println );  // Before Java 25, swap out `IO` for `System.out`. 

When run:

Employee[name=Carol, hired=2018-01-23]
Employee[name=Bob, hired=2019-01-23]
Employee[name=Alice, hired=2022-01-23]
Employee[name=Davis, hired=2025-01-23]

Pass the ArrayList In argument.

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

        }
    });
}