Come mai il parametro di tipo generico dice "estende" Paragonabile non "implementa"?

Question

Ho cercato di scrivere funzione generica che rimuove gli elementi duplicati da matrice.

public static <E extends Comparable<E>> ArrayList<E> removeDuplicate(E[] arr) { 
    //do quicksort 
    Arrays.sort(arr); 
    ArrayList<E> list = new ArrayList<E>(); 
    int i; 
    for(i=0; i<arr.length-1; i++) { 
     if(arr[i].compareTo(arr[i+1]) != 0) { //if not duplicate, add to the list 
      list.add(arr[i]); 
     } 
    } 
    list.add(arr[i]); //add last element 
    return list; 
} 

Come si può vedere non è possibile passare tipo primitivo come int [] array dal momento che sto paragonando elementi da compareTo() metodo che definito nella interfaccia Comparable.

ho notato la prima linea (dichiarazione di metodo):

public static <E extends Comparable<E>> ArrayList<E> removeDuplicate(E[] arr) { 

Come mai si dice "si estende comparabile"?

Comparabile è un'interfaccia, quindi perché non "implementare Comparabile"? Questa è la prima volta che scrivo la funzione generica, quindi sono un po 'confuso su tali dettagli. (qualsiasi dubbio potrebbe impedirmi di capire ..)

MODIFICA: trovato questo articolo correlato.

http://www.tutorialspoint.com/java/java_generics.htm

Answer 1

Se si desidera utilizzare la cosa che si attua solo Wirte è parametro come generico

class Bar extends Foo<String> { /* Code */} 

Il jolly che si sta parlando sono tre

1. "si estende Tipo?": Denota una famiglia di sottotipi di tipo Tipo. Questo è il jolly più utile
2. "super Type?": Indica una famiglia di supertipi di tipo tipo
3. "?": Indica l'insieme di tutti i tipi o qualsiasi

metodo che si deve sembrano

public static <T extends Comparable<? super T>> Collection<T> sort(T[] list) { 

     Collection<T> list = new ArrayList<T>(); 

     //do quicksort 
     Arrays.sort(arr); 

     Collection<T> list = new ArrayList<T>(); 
     int i; 
     for(i=0; i<arr.length-1; i++) { 
      if(arr[i].compareTo(arr[i+1]) != 0) { //if not duplicate, add to the list 
       list.add(arr[i]); 
      } 
     } 
     list.add(arr[i]); //add last element 
//btw how do You know that last is not duplicate 
     return list; 

} 

Per suppliche detali visitare this page

Answer 2

Per prima cosa, E potrebbe essere un'interfaccia.

Answer 3

Questo è solo la convenzione scelta per i generici. Quando si utilizzano parametri di tipo limitato si utilizza estende (anche se potrebbe significare implementazioni in alcuni casi) o super.

Si può anche fare qualcosa come <E extends Comparable<E> & Cloneable> per definire che l'oggetto che sostituirà il parametro di tipo dovrebbe implementare entrambe quelle interfacce.