How come generic type parameter says "extends" Comparable not "implements"? [duplicate]

This question already has answers here: Why is "extends T" allowed but not "implements T"? (9 answers) Closed 3 years ago.

I tried to write generic function that remove the duplicate elements from array开发者_JAVA百科.

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

As you can see you can't pass primitive type like int[] array since I am comparing elements by compareTo() method that defined in Comparable interface.

I noticed the first line (method declaration):

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

How come it says "extends Comparable" ?

Comparable is an interface so why is it not "implement Comparable"? This is first time I wrote generic function so I'm bit confused about such detail. (any wondering would prevent me from understanding..)

EDIT: Found this article related to this topic.

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

---

This is just the convention chosen for generics. When using bounded type parameters you use extends (even though it might mean implements in some cases) or super.

You can even do something like <E extends Comparable<E> & Cloneable> to define that the object that would replace the type parameter should implement both those interfaces.

---

If You want to use the thing that implements You just write is as generic parameter

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

The wildcard that You are talking about are three

1. "? extends Type": Denotes a family of subtypes of type Type. This is the most useful wildcard
2. "? super Type": Denotes a family of supertypes of type Type
3. "?": Denotes the set of all types or any

You method should look like

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;

}

For detail please visit this page

---

For one thing, E might be an interface.