Comparador de Java Genérico

Pizza :

public class arr<T>
{
    class comp <T extends Comparable<T>> implements Comparator<T>
    {
        public int compare(T lObj,T rObj)
        {
              return lObj.compareTo(rObj);
        }
    }

    ArrayList<T> list;
    Comparator<T> comparator;
    public arr()
    {
        list = new ArrayList<T>();
        comparator = new comp();
    }
    public void add(T data)
    {
        list.add(data);         
    }
    public int getLength()
    {
        return list.size();
    }
    public T get(int index)
    {
        return list.get(index);
    }
    public void sort()
    {
        list.sort(comparator);
    }
}

Hola, Estoy tratando de hacer el trabajo de función de clasificación, pero tienen un problema. En el arr constructor, si escribo

comparator = new comp<T>();

me da un dicho error

"type argument T#1 is not within bounds of type-variable T#2 comparator = 
new comp<T>();                            ^
where T#1,T#2 are type-variables:
T#1 extends Object declared in class arr
T#2 extends Comparable<T#2> declared in class arr.comp"

Y si tomo el tipo y la escritura como esto

comparator = new comp;

entonces se hace el trabajo, pero me da un aviso que dice

warning: [rawtypes] found raw type: arr.comp
comparator = new comp();

Puedo ver lo que quiere decir con tipos primas. No estoy especificando el tipo, pero de alguna manera funciona y si trato de fijar la advertencia especificando el tipo de entonces, se genera un error. ¿Podrían ayudarme a resolverlo? Yo sé ... yo soy un novato mi código debe ser un dolor en sus ojos. Estoy jugando con comparadores genéricos e intentar muchas cosas para familiarizarse. Gracias.

Andreas:

Su código que es confuso, ya que el Tdefinido por compestá escondiendo la Tdefinida por arr. Para la explicación a continuación, los llamaré Tcompy Tarr.

Tcompque se requiere para extender Comparable, pero Tarrno está obligado a hacerlo, lo que significa que Tarrno pueden ser "mapeados" a Tcomp.

Para solucionarlo, el cambio Tarrpor lo que se requiere también para ampliar Comparable:

public class arr<T extends Comparable<T>>

---

En una nota:
Usted compclase es una clase interna, pero que no utiliza nada de la clase externa, por lo que debe ser una clase anidada estática:

static class comp<T extends Comparable<T>> implements Comparator<T>

Como alternativa, dejar compcomo una clase interna, y dejar que se reutilice el Tde la clase externa:

class arr<T extends Comparable<T>>
{
    class comp implements Comparator<T>

Pero, ya que Java (8 o superior) viene con una implementación de Comparatorpara comparar Comparableobjetos, que se debe utilizar:

public class arr<T extends Comparable<T>>
{
    ArrayList<T> list;
    Comparator<T> comparator;
    public arr()
    {
        list = new ArrayList<T>();
        comparator = Comparator.naturalOrder();
    }
    // rest of code
}