¿Cómo es que el parámetro de tipo genérico dice "extiende" Comparable no "implementa"?

Question

Traté de escribir una función genérica que elimine los elementos duplicados de la matriz.

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; 
} 

Como se puede ver no se puede pasar tipo primitivo como array int [] desde que estoy comparando elementos por() método que se define en la interfaz Comparable compareTo.

me di cuenta de la primera línea (declaración de método):

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

¿Cómo es que se dice que "se extiende comparable"?

Comparable es una interfaz, ¿por qué no es "implementar Comparable"? Esta es la primera vez que escribo una función genérica, así que estoy un poco confundido acerca de esos detalles. (cualquier duda me impediría comprender ...)

EDIT: encontrado este artículo relacionado con este tema.

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

Answer 1

Si Usted desea utilizar lo que usted implementa simplemente wirte es el parámetro como genéricos

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

El comodín que estamos hablando son tres

1. "se extiende Type?": Denota una familia de subtipos de tipo Tipo. Este es el comodín más útil
2. "super Tipo?": Denota una familia de supertipos de tipo Tipo
3. "?": Denota el conjunto de todos los tipos o cualquier

método que vaya parecen

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; 

} 

Para peticiones detali visitan this page

Answer 2

Por un lado, E podría ser una interfaz.

Answer 3

Esto es solo la convención elegida para genéricos. Al utilizar parámetros de tipo delimitados, utiliza extends (aunque podría significar implementa en algunos casos) o super.

Incluso puede hacer algo como <E extends Comparable<E> & Cloneable> para definir que el objeto que reemplazaría el parámetro de tipo debería implementar ambas interfaces.