[JAVA] Generics

[feboss]

Ho un problema che non riesco a risolvere probabilmente a causa della mia scarsa comprensione dei generics

Ho una lista così composta

public class Lista<E extends Comparable<E>>
private NodoL<E> Testa;
private NodoL<E> Coda;
...

e un nodo così composto

public class NodoL<E>
{
    private NodoL<E> next;
    private NodoL<E> prev;
    private E info;
...

Per una serie di motivi devo effettuare un inserimento

public void inserisciTesta(E val)
    {
        if (isEmpty())
            Testa = Coda = new NodoL<E>(val);
        else
            Testa = Testa.setPrev(new NodoL<E>(val, Testa, null));
    }

Ma non riesco a inserire un oggetto NodoL all'interno della lista.
Probabilmente perché dovrei implementare il compareTo.
Esiste un modo per procedere evitando di modificare la lista facendole accettare oggetti senza l'implementazione di compareTo?
qualcuno ha qualche idea?

[wingman87]

L'unico modo è togliere quel "extends Comparable<E>" nella dichiarazione della classe Lista, ma se hanno messo questa restrizione forse è perché l'implementazione della lista fa uso dei metodi degli oggetti Comparable. Se così fosse devi far implementare Comparable agli oggetti che vuoi metterci dentro

[feboss]

quell'extends comparable è li per evitare di castare a comparable quando faccio i confronti con il compareTo...Come ad esempio avviene negli inserimenti ordinati
Dici di modificare la lista eliminando l'extends comparable e facendo i cast dove servono?

[wingman87]

Non so se ho capito bene, nei metodi di Lista in effetti usi dei metodi che sono propri di Comparable? Se eliminassi "extends Comparable<E>" ma continuassi ad usare il metodo compareTo, anche con il cast, non cambierebbe nulla, darebbe errore a runtime invece che a compiletime che è molto peggio.

[feboss]

uso solo il compareTo nei metodi di alcuni inserimenti(quelli ordinati)
Ho tolto l'extends comparable lasciando così:
public class Lista<E>
e adesso mi fa inserire una classe nodo ma ho un altro problema

Ho 2 classi nodo.una per la lista e una di un albero
NodoA e NodoL
Nella classe Albero ho inizializzato la lista e inserito il nodo dell'albero(NodoA).Fin qui nessun problema.
Quando però tento di estrarre il nodoA precedentemente inserito,mi da errore perché il metodo estrai(della lista) ha un return di tipo NodoL
normalmente la cosa dovrebbe risolversi con un cast...ma niente mi dice "inconvertible types"

una giornata a

edit: Risolto! sbagliavo e inserivo il campo nodo al posto del campo info(che in quel caso era il nodo che mi serviva)
io però non ho ancora capito sti generics.Pensavo fossero qualcosa che ti permetteva di avere un po più di flessibilità e astrazione.e invece mi ritrovo un listato pieno di warning che se per sbaglio inserisco un dato sbagliato mi esce un errore che non finisce più.
Molto probabilmente li uso nella maniera sbagliata. Resta il fatto che il mio listato è diventato poco leggibile dopo aver tolto <E Extends Comparable<E>> e aver fatto tutti i cast

[feboss]

riformulo il problema.Magari riesco a spiegarmi meglio

Devo implementare una visita a livelli di un albero e per la mia soluzione decido di utilizzare un struttura di appoggio FIFO.
opto per una lista
Quindi ho:
Albero.java e NodoA.java
Lista.java e NodoL.java

ad un certo punto devo inserire il nodo dell'albero all'interno della lista
quindi il metodo è questo:

private void xlivelli(Nodo<E> n)
    {
          Lista<Nodo> lista = new Lista<Nodo> ();

          if(n!=null)
          {
              lista.inserisciTesta(n);
              while(!lista.isEmpty())
              {
                  n = lista.getCoda().getInfo();
                  lista.eliminaCoda();

                  System.out.print(n.getInfo()+ " ");
                  if(n.getFiglio()!=null)
                      lista.inserisciTesta(n.getFiglio());
                  if(n.getDestro()!=null)
                      lista.inserisciTesta(n.getDestro());
              }
          }
    }

io voglio tenermi la lista come
Lista<E extends Comparable<E>>
non si può? Se tolgo l'extends devo fare tutti i cast a comparable nei metodi di inserimento ordinato.e il codice diventa inguardabile

Quindi a cosa mi serve sto <E>
non facevo prima a lasciare la lista con i campi informazioni di tipo Object?
non ci sto capendo più nulla

[PGI-Bis]

I tipi generici non sono altro che delle definizioni di operatori sui tipi e quando specifichi un limite superiore o inferiore nella loro dichiarazioni riduci l'insieme dei tipi a cui puoi applicarli secondo uno o più vincoli.

Nel nostro caso Lista è un operatore sui tipi comparabili con altri della stessa specie.

Se Nodo non è comparabile con altri Nodo la lista non può che rifiutarlo. E' come definire la somma tra numeri interi e poi cercare di usarla per sommare una frittata e un paracarro: non funziona, l'operatore non è "conscio" delle caratteristiche di frittate e paracarri.

Se questo è il problema allora hai due soluzioni: anzichè Nodo usi qualcosa che rispetti il vincolo degli operandi di Lista (l'essere comparabile) o rilassi quel vincolo.

La seconda mi sembra più opportuna.

Anzichè Lista<E extends Comparable<E>> puoi usare Lista<E> e dichiarare un costruttore che piglia un Comparator<E> come argomento: non devi fare conversioni esplicite e puoi ordinare gli elementi nella lista usando il comparatore.

[feboss]

Cortesemente puoi farmi un esempio pratico?
ad esempio:
ricerca di un elemento nella lista

public boolean trovab(E val)
    {
        NodoL<E> Temp;
        for (Temp = Testa; Temp != null && ((Comparable)Temp.getInfo()).compareTo(val) != 0; Temp = Temp.getNext());
        return Temp != null;
    }

oppure inserimento ordinato:

public void inserisciOrdinato(E val)
    {
        if ( isEmpty() || ((Comparable)Testa.getInfo()).compareTo(val) >= 0)
            inserisciTesta(val);
        else
        {
            NodoL<E> Temp;
            for (Temp = Testa; Temp != null && ((Comparable)Temp.getInfo()).compareTo(val) < 0; Temp = Temp.getNext());
            if (Temp == null)
                inserisciCoda(val);
            else
                Temp.getPrev().setNext(Temp.setPrev(new NodoL<E>(val, Temp, Temp.getPrev())));
        }
    }

[PGI-Bis]

Anzichè fare la conversione esplicita a Comparable supponendo che il parametro di tipo Comparator ricevuto dal costruttore sia assegnato ad un campo di nome "comparator" scrivi:

Temp != null && comparator.compare(temp.getInfo(), val) != 0 ...eccetera

Tutto qua. Comparator è simile a Comparable solo che il metodo compare accetta due argomenti: puoi vedere il primo dei due come se fosse il "this" di Comparable, la funzione è identica.

[feboss]

le ho provate tutte ma non ci sono riuscito
Utilizzando il compare mi dice che non posso instanziarlo da un static context
e se passo come parametro Comparator<E> val, non posso fare gli inserimenti se non li casto a (E)

lascio perdere e me lo tengo con i cast a comparable