Collections.sort) dichiarazione (: perché <? super T> piuttosto che <T>

Question

Perché Collections.sort(List<T>) ha la firma:

public static <T extends Comparable<? super T>> void sort(List<T> list) 

e non:

public static <T extends Comparable<T>> void sort(List<? extends T> list) 

• ho capito che entrambi avrebbero servire allo stesso scopo; quindi perché gli sviluppatori di framework hanno usato la prima opzione?
• Oppure queste dichiarazioni sono davvero diverse?

Answer 1

La firma proposta probabilmente funzionerebbe in Java-8. Tuttavia nelle precedenti versioni di Java l'inferenza di tipo non era così intelligente. Considera che hai List<java.sql.Date>. Notare che java.sql.Date estende java.util.Date che implementa Comparable<java.util.Date>. Quando si compila

List<java.sql.Date> list = new ArrayList<>(); 
Collections.sort(list); 

Funziona perfettamente in Java-7. Qui T è dedotto per essere java.sql.Date che è in realtà Comparable<java.util.Date> che è Comparable<? super java.sql.Date>. Tuttavia proviamo la tua firma:

public static <T extends Comparable<T>> void sort(List<? extends T> list) {} 

List<java.sql.Date> list = new ArrayList<>(); 
sort(list); 

Qui T può essere presupposta come java.util.Date. Tuttavia, le specifiche Java 7 non consentono tale inferenza. Quindi questo codice può essere compilato con Java-8, ma non riesce quando compilato sotto Java-7:

Main.java:14: error: method sort in class Main cannot be applied to given types; 
     sort(list); 
     ^
    required: List<? extends T> 
    found: List<Date> 
    reason: inferred type does not conform to declared bound(s) 
    inferred: Date 
    bound(s): Comparable<Date> 
    where T is a type-variable: 
    T extends Comparable<T> declared in method <T>sort(List<? extends T>) 
1 error 

Tipo inferenza è notevolmente migliorata in Java-8. A JLS chapter 18 è dedicato separatamente, mentre in Java-7 le regole were sono molto più semplici.

Answer 2

Differiscono perché ? super T è meno restrittivo di T. Si tratta di una Lower Bounded Wildcard (Java Tutorial legata dice, in parte)

Il termine List<Integer> è più restrittiva rispetto List<? super Integer> perché il primo corrisponde a un elenco di tipo Integer solo, mentre il secondo corrisponde a un elenco di qualsiasi tipo che è un supertipo di Integer.

Sostituire Integer con T e significa un To un java.lang.Object.

Answer 3

// 0 
public static <T extends Comparable<? super T>> void sort0(List<T> list) 

// 1 
public static <T extends Comparable<T>> void sort1(List<? extends T> list) 

Queste firme differiscono in quanto impongono requisiti diversi sul rapporto tra tipo T e il tipo argomento per Comparable nella definizione di T.

Supponiamo per esempio di avere questa classe:

class A implements Comparable<Object> { ... } 

Quindi se avete

List<A> list = ... ; 
sort0(list); // works 
sort1(list); // fails 

La ragione sort1 non è che non c'è non tipo T che sia paragonabile a se stesso e cioè, o è un supertipo di, il tipo della lista.

Si scopre che la classe A non è valida, poiché gli oggetti che sono Comparable devono soddisfare determinati requisiti. In particolare, invertire il confronto dovrebbe invertire il segno del risultato. Possiamo confrontare un'istanza di A in un Object ma non viceversa, quindi questo requisito è violato. Tuttavia, si noti che questo è un requisito della semantica di Comparable e non è imposto dal sistema di tipi. Considerando solo il sistema di tipi, le due dichiarazioni sort sono davvero diverse.