Lambda sort using Reflection

I'm working on a project that requires the use of sorted Class lists, and I have a lambda expression that worked according to the type of class I needed to be sorted. The sorting occurs on a date field of the class itself:

Comparator<Class1> comparatorDescending = (exp1, exp2) -> exp2.getDate().compareTo(exp1.getDate());
        this.classlist2sort.sort(comparatorDescending);

However I have two, maybe more classes that need to be sorted in this way and I decided to move the lambda expression above to the parent class and make it a generic. This required a bit of work however in that I now need to pass into the parent class the type of class I'm dealing with (Class1.class), condition on that, then sort with generic. I tried the following using Reflection:

Method m = this.typeParameterClass.getDeclaredMethod("getDate");

Comparator<T> comparatorDescending = (exp1, exp2) ->
                m.invoke(exp2).compareTo(m.invoke(exp1));
this.classlist2sort((Comparator<? super T>) comparatorDescending);

Doing so gave me an error message: Unhandled exceptions: java.lang.IllegalAccessException, java.lang.reflect.InvocationTargetException to which I followed the suggested workaround of surrounding the expression with a try catch in the following manner:

Method[] input = this.typeParameterClass.getDeclaredMethods();
Method m = this.typeParameterClass.getDeclaredMethod("getDate");

Comparator<T> comparatorDescending = (exp1, exp2) -> {
            try {
                return m.invoke(exp2).compareTo(m.invoke(exp1));
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
this.classlist2sort((Comparator<? super T>) comparatorDescending);

Unfortunately, doin this resulted in a Cannot resolve method 'compareTo' in 'Object' error. I am wondering now if what I'm trying to do is possible. Any help is appreciated

You can cast the return value of the method to Comparable (you will have to make sure the return value of getDate matches this). The comparator can also be simplified using Comparator.comparing.

try {
	Method m = this.typeParameterClass.getDeclaredMethod("getDate");
	this.classlist2sort.sort(Comparator.comparing(o -> {
		try {
			return (Comparable) m.invoke(o);
		} catch (IllegalAccessException | InvocationTargetException e) {
			throw new RuntimeException(e);
		}
	}).reversed());
} catch (NoSuchMethodException e) {
	throw new RuntimeException(e); // or other handling
}

If you have access to the source code of Class1, Class2, etc. you can define an interface to be used for the comparator and avoid reflection altogether. Let's say:

public interface HasDate {

  LocalDate getDate();
}

I know the name is bad, but it will do for an example. Define the comparator to work with HasDate, and you can sort lists, whose elements implement the interface.

public class RandomStuff {

  public static void main(String[] args) {
    Comparator<HasDate> dateComparator = (o1, o2) -> o2.getDate().compareTo(o1.getDate());

    List<Class1> list1 = new ArrayList<>();
    list1.add(new Class1(LocalDate.now()));
    list1.add(new Class1(LocalDate.now().plusDays(1)));
    list1.add(new Class1(LocalDate.now().minusDays(1)));
    list1.sort(dateComparator);
    System.out.println(list1);

    List<Class2> list2 = new ArrayList<>();
    list2.add(new Class2(LocalDate.now()));
    list2.add(new Class2(LocalDate.now().plusDays(1)));
    list2.add(new Class2(LocalDate.now().minusDays(1)));
    list2.sort(dateComparator);
    System.out.println(list2);
  }
}