Question

We have made in a tutorial an example with the following signture (as part of an interface)

<T> List<Comparable<T>> sort(Collection<Comparable<T>> c, boolean ascending);

We have found it nearly impossible to implement that method without warnings:

public <T> List<Comparable<T>> sort(Collection<Comparable<T>> c, boolean ascending) {
    List<T> list = new ArrayList<T>();
    Collections.sort(list);
    return list;
}

The error in the line Collections.sort(list) we get is:

Bound mismatch: The generic method sort(List<T>) of type Collections is not 
applicable for the arguments (List<T>). The inferred type T is not a valid 
substitute for the bounded parameter <T extends Comparable<? super T>>

However, it works for the following signature:

<T extends Comparable<T>> List<T> sort(Collection<T> c, boolean ascending);

With that signature, the code above (implementation of sort) just works as expected. I would like to know what is the reason for that.

Answer 1

Collections.sort expects a List<T extends Comparable<? super T>>, i.e. the compiler needs to be able to tell that the element type T of the list it is sorting extends Comparable<E> where E is T, a superclass of T or an interface implemented by T. Your first signature with public <T> List<Comparable<T>> sort doesn’t enforce this, so you can’t Collections.sort a List<T>. You could make it work by saying

List<Comparable<T>> list = new ArrayList<Comparable<T>>();

to match the type that your sort method returns, but the problem with this is that it’s rather inflexible – it can only sort a Collection<Comparable<Foo>>, not a Collection<Bar> where Bar implements Comparable<Foo>. The most flexible approach would be to stick with the new ArrayList<T>() but use a signature like

<T extends Comparable<? super T>> List<T> sort(Collection<T> c, boolean ascending);

which places the minimum restriction on T to make the sort valid – it would work with Bar extends Foo implements Comparable<Foo>, which your second signature doesn’t allow (that would require Bar implements Comparable<Bar>).