Comparable Interface

Question

Why is it beneficial to implement the Comparable interface instead of just defining my own compareTo() method?

Another thing, how does the java.util.Arrays.sort(Object[] o) method relate to the Comparable interface such that I HAVE to implement the Comparable interface to be able to use the Arrays.sort(Object[] o) method?

Answer 1

Why is it beneficial to implement the Comparable interface instead of just defining my own compareTo method?

You can define your own method, but all the classes, which need to compare must know it. Comparable is there in Java api for this purpose and all peoples know it well. Comparable interface is a super type for many classes, regardless of their origin. So, it's commonly used in all major frameworks.

Another thing, how does the java.util.Arrays.sort(Object[] o) method relate to the Comparable interface such that I HAVE to implement the Comparable interface to be able to use the Arrays.sort(Object[] o) method?

Arrays.sort() method internally calls the compareTo() method of Comparable classes to sort the content.

Check the source code of Arrays.sort(), the delegating method use the Comparabble#compareTo() method

private static void mergeSort(Object[] src,
                  Object[] dest,
                  int low,
                  int high,
                  int off) {
    int length = high - low;

    // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
             ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }