No suitable method found for sort(object[],class)

Question

I have an array of Appointment objects that I would like to sort based on a few field.

Appointment class with overridden compareTo

public class Appointment implements Comparable<Appointment>{
    
    String month;
    String day;
    int hour;
    int minute;
    String description;

    // constructor, getters and setters omitted to emphasize Comparable implementation

    @Override
    public int compareTo(Appointment other){
        
        if (this.month.compareTo(other.month) == 0){
            return 0;
        } else if (this.month.compareTo(other.month) > 0){
            return 1;
        } else if (this.month.compareTo(other.month) < 0){
            return -1;
        }
        
        
        if (this.day.compareTo(other.day) == 0){
            return 0;
        } else if (this.day.compareTo(other.day) > 0){
            return 1;
        } else if (this.day.compareTo(other.day) < 0){
            return -1;
        }
        
        
        if (this.hour == other.hour){
            return 0;
        } else if (this.hour > other.hour){
            return 1;
        } else if (this.hour < other.hour){
            return -1;
        }
        
        
        if (this.minute == other.minute){
            return 0;
        } else if (this.minute > other.minute){
            return 1;
        } else if (this.minute < other.minute){
            return -1;
        }
        
        return 0;
    }
}

Issue

In my main class, named Calendar, I create and save a number of Appointment objects to the array bookings.

However I cannot sort the list with the compareTo method I defined.

Collections.sort(bookings, new Appointment());

This gives me the error:

No suitable method found for sort(object[],Appointment)

Any idea how I could solve this?

Answer 1

Read also this intro on DZone Java: Java Comparable Interface in Five Minutes

Using the Collections.sort method

To use a class implementing Comparable in Collections.sort(List<T> comparables) method like:

// class Appointment implements Comparable 
Appointment[] arrayOfAppointments = createAppointments(); // sample of appointments
// we need a list for Collections.sort
List<Appointment> appointments = Arrays.asList(arrayOfAppointments); 

// sort them based on Comparable implementation 
Collections.sort(appointments); // no second argument (specific Comparator) needed

You have correctly implemented the interface Comparable with its method compareTo in your class.

At least you need a list or array of Appointment objects which implement Comparable.

Use the Arrays.asList method as matt suggested as bridge:

This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray().

There are two things to notice when applying the method sort on a List:

1. The list must be mutable, because ..

   The specified list must be modifiable, but need not be resizable.

2. The method has no return (void), it modifies and sorts it in-place.

Sorting objects composed by other comparables

Instead of re-implementing the 3 sort-results like for example on month:

        if (this.month.compareTo(other.month) == 0) {
            return 0;
        } else if (this.month.compareTo(other.month) > 0){
            return 1;
        } else if (this.month.compareTo(other.month) < 0){
            return -1;
        }

you can simply benefit from comparable Integers:

// If typed String: "April" is before "February" alphabetically but not chronologically!
Integer month; // we can compare ordered month-numbers easily

// later
@Override
public int compareTo(Appointment other) {
    // What if other is null, or one of its fields or components ?
    // What if they are equal? Shouldn't we compare on the next (day) then ?!
    return this.month.compareTo(other.month);
    
    // next components are compared in the following

    return 0;  // default result: objects are equal ?!
}

Potential logical bugs in your sorting-logic (also commented in code above):

1. early returns (e.g. for equal months) if not fully compared to the minor temporals (e.g. differ only in minute)
2. default return states that objects are equal
3. no null-check on other or its components (may cause NPE)

Why not using date/time classes?

It gets even easier if the date of an appointment is stored as such, using java.util.Date or any date-class of new Java Date/Time API. So you can compare the dates entirely, without bothering for details of month, day, hour, minute.