[Java] Generics: Interfaccia Comparable

[fabbio86]

Ciao a tutti!

Ho un metodo add(T) dove T extends Comparable<T> e un array di Object arr. In realtà so che gli oggetti contenuti in arr sono tutti di tipo T e dello stesso sottotipo (o Integer o String o Double...).
Vorrei usare il metodo add passandogli come argomento gli oggetti contenuti nell'array.
Ho trovato questa (brutta) soluzione, che infatti solleva un warning di type-safety:

for(int i = 0; i < arr.length; i++){
p.add((T)(arr[i]));
}

Esiste un modo migliore?
Ho pensato a fare una selezione del tipo

if(arr[i] instanceof Integer){
p.addLast((T)(arr[i]));
}
if(Arr[i] instanceof String){
p.addLast((T)(arr[i]));
}...

Ma forse esiste un modo più furbo...
Premetto che mi sono letto il tutorial sui Generics ma non è che i concetti mi siano el tutto chiari.

Grazie!

Saluti

[andbin]

Originariamente inviato da fabbio86
Ciao a tutti!

Ho un metodo add(T) dove T extends Comparable<T> e un array di Object arr. In realtà so che gli oggetti contenuti in arr sono tutti di tipo T e dello stesso sottotipo (o Integer o String o Double...).
Vorrei usare il metodo add passandogli come argomento gli oggetti contenuti nell'array.
Ho trovato questa (brutta) soluzione, che infatti solleva un warning di type-safety:

for(int i = 0; i < arr.length; i++){
p.add((T)(arr[i]));
}

Innanzitutto dovresti spiegare meglio come è questo metodo add(). L'hai fatto tu? O è uno delle classi collection? Poi in quest'ultimo punto dove fai p.add, 'T' è il type parameter di cosa?

[fabbio86]

Hi!

Add è un metodo che ho scritto io. Appartiene alla classe DouLinkList così definita:

public class DouLinList<T extends Comparable<T>> implements lista<T>

L'interfaccia è invece:

interface lista<T extends Comparable<T>>
...
void add(T val);
...

[andbin]

Originariamente inviato da fabbio86
Add è un metodo che ho scritto io. Appartiene alla classe DouLinkList così definita:

public class DouLinList<T extends Comparable<T>> implements lista<T>

L'interfaccia è invece:

interface lista<T extends Comparable<T>>
...
void addFirst(T val);
...

Ok, però ti faccio notare alcune cose.

Se usi i generics, allora quando definisci una variabile di tipo DouLinList, devi specificare una istanziazione (concreta o wildcard) della classe generica.

Se fai:
DouLinList<String> list = .....

allora è chiaro che potrai inserire nella lista solo degli oggetti String. Insomma ... non vedo il problema. Dipende da cosa hai scritto (che non l'hai specificato).

Poi un'altra cosa su Comparable. Non mi è chiaro il perché hai dovuto limitare il tipo della lista in modo che sia un Comparable. Le classi collection nel framework di Java non hanno questa limitazione. Cioè, normalmente non è necessaria. In altri termini: perché non vuoi poter avere una lista di elementi non comparabili??? (non c'è nulla di male in questo ... vorrei saperlo anche solo per mia curiosità).

Se poi devi proprio limitare ai tipi Comparable, allora sappi che la dichiarazione che hai scritto è un pochino ristretta. La forma più "ampia" è:

<T extends Comparable<? super T>>

[fabbio86]

Se usi i generics, allora quando definisci una variabile di tipo DouLinList, devi specificare una istanziazione (concreta o wildcard) della classe generica.

Ok, e qui sta il senso della mia domanda: esiste un modo di scrivere codice generale per qualunque classe concreta?

Non mi è chiaro il perché hai dovuto limitare il tipo della lista in modo che sia un Comparable.

Non è chiaro neanche a me ma è stato esplicitamente richiesto. Fosse per me cambierei Object[] arr in T[] Arr e sarei a posto.

Se poi devi proprio limitare ai tipi Comparable, allora sappi che la dichiarazione che hai scritto è un pochino ristretta. La forma più "ampia" è:

Non ho ben capito cosa intendi... Quale dichiarazione?
Ma tornando al problema originale cosa devo scrivere al posto di:
p.add((T)(arr[i]));
per eliminare il warning e ottenere l'effeto voluto?

[andbin]

Originariamente inviato da fabbio86
Ok, e qui sta il senso della mia domanda: esiste un modo di scrivere codice generale per qualunque classe concreta?

Cioè??? Non ti sei espresso affatto bene. Sai bene come funzionano i generics e cosa sono i wildcard??

Originariamente inviato da fabbio86
Non ho ben capito cosa intendi... Quale dichiarazione?

Tu hai scritto:

public class DouLinList<T extends Comparable<T>> .....blabla

Indicare che deve essere Comparable esattamente di tipo T è limitante. Posso farti un esempio:

class Veicolo implements Comparable<Veicolo>
{
    private String targa;
    
    // .....costruttori ecc.....

    public int compareTo (Veicolo v)
    {
        return targa.compareTo (v.targa);
    }
}

class Automobile extends Veicolo { ..... }
class Motocicletta extends Veicolo { ..... }

In questo caso se tu facessi:

DouLinList<Automobile> listaAuto = new DouLinList<Automobile> ();

NON compilerebbe nonostante due oggetti Automobile siano realmente davvero comparabili!!

Ecco perché la forma più "ampia" è:

public class DouLinList<T extends Comparable<? super T>> .....blabla

Originariamente inviato da fabbio86
Ma tornando al problema originale cosa devo scrivere al posto di:
p.add((T)(arr[i]));
per eliminare il warning e ottenere l'effeto voluto?

Dovresti dire di che tipo è la tua lista.

Cioè hai fatto:

DouLinList<String> mialista = new DouLinList<String> ();

oppure

DouLinList<Integer> mialista = new DouLinList<Integer> ();

o altro?

Il nocciolo è lì.

[fabbio86]

Dovresti dire di che tipo è la tua lista.
Cioè hai fatto:
DouLinList<String> mialista = new DouLinList<String> ();
oppure
DouLinList<Integer> mialista = new DouLinList<Integer> ();
o altro?

Capisco...Possibile che non esista un modo per scrivere codice indipendentemente dal tipo della lista?

** EDIT **
Anche così non funziona (add richiede T e non Integer o String, anche se T può essere Integer o String)

for(int i = 0; i < arr.length; i++){
     if(arr[i] instanceof Integer)
          p.add((Integer)(arr[i]));
     if(arr[i] instanceof String)
          p.add((String)(arr[i]));
     if(arr[i] instanceof Double)
          p.add((Double)(arr[i]));
...
} 

[andbin]

Originariamente inviato da fabbio86
Capisco...

No, purtroppo non hai capito....

Originariamente inviato da fabbio86
Possibile che non esista un modo per scrivere codice indipendentemente dal tipo della lista?

Sì che è possibile ma entrano in gioco, i "bounds", i "wildcard", i metodi generici, la type inference e il "wildcard capture".

E comunque bisogna valutare attentamente che cosa si vuole fare sulla lista. Mi spiego meglio: per poter ad esempio "rovesciare" il contenuto di una lista non è fondamentale sapere di che tipo è la lista. Se invece vuoi aggiungere elementi ad una lista, allora è fondamentale sapere di che tipo è la lista.