Salve ragazzi, sto impazzendo da giorni e giorni con un esercizio ma non riesco a venirne a capo.
Ecco il testo:
codice:
Si fornisca un'efficiente implementazione dell'interfaccia StackSet140910<E>, come mostrata nella pagina successiva. La classe rappresenta un insieme ordinato i cui elementi sono semplici stack (classe MStack<E>). Ogni stack dell'insieme è rappresentato dal suo elemento che si trova in cima allo stack. Ogni stack potrà contenere al massimo 50 elementi. L'insieme dovrà essere rappresentato attraverso una lista concatenata e gli stack dell'insieme dovranno essere ordinati in base al loro elemento rappresentante. Uno stack che non contiene alcun elemento dovrà apparire nella lista prima di qualsiasi altro stack (considerarlo come l'elemento più piccolo dell'insieme) La gestione delle eccezioni all'interno delle classi è facoltativa. Realizzare in seguito, mediante il metodo main() della classe, un programma Java che prenda in input un file di testo contenente una sequenza di numeri interi e restituisca in output un file di testo contenente le specifiche della struttura ottenuta dopo l'inserimento di tali numeri a partire da uno StackSet140910 contenente 3 stack vuoti. 
 Il file di input contiene una sequenza di numeri interi, uno per riga.
File di output Il file di output dovrà contenere la lista degli elementi contenuti nei tre stack dell'insieme (uno stack per riga), iniziando dagli elementi che si trovano in cima alla struttura. 

Interfaccia StackSet140910 import java.util.*; 
public interface StackSet140910<E> extends Iterable<E>
{ 
public int stacks (); // ritorna il numero di stack (di tipo MStack<E>) dell'insieme 
public int items (); // ritorna il numero di elementi (E) dell'insieme 
public MStack<E> getMin (); /** ritorna il primo stack vuoto dell'insieme. Se non esistono stack vuoti nell'insieme ritorna lo stack con il più piccolo valore in testa */
public E pop (); // effettua il pop sul primo stack dell'insieme 
public void push (E elem); // effettua il push di un elemento sul primo stack dell'insieme 
public void addStack (); // aggiunge un nuovo stack vuoto all'insieme
 public Iterator<E> iterator(); // ritorna un iteratore di tutti gli elementi (di tipo E) // contenuti negli stack dell'insieme }

Ecco invece il mio codice:
codice:
import java.io.*;
import java.util.*;

public class LinkedList<E extends Comparable>
{
    protected NodoL<E> header, trailer;
    private int size;
    
    public LinkedList()
    {
        header=new NodoL<E>(null,null,null);
        trailer=new NodoL<E>(null,header,null);
        size=0;
    }
    
    public int size()
    {
        return size;
    }

    public boolean isEmpty()
    {
        return (size==0);
    }
    
    //ritorna il primo elemento
    public NodoL<E> first()
    {
        if(isEmpty())
            return null;
        else
            return header.getNext();
    }
    
    //ritorna l'ultimo elemento
    public NodoL<E> last()
    {
        if(isEmpty())
            return null;
        else
            return trailer.getPrev();
    }
    
    //aggiungo all'inizio
    public void addFirst(E element)
    {
        NodoL<E> newNodo=new NodoL<E>(element,header,header.getNext());
        header.getNext().setPrev(newNodo);//quello che era il successore di header, adesso avrà come predecessore il nuovo nodo
        header.setNext(newNodo);//imposto il successore di header
        size++;
    }
    
    //aggiungo alla fine 
    public void addLast(E element)
    {
        NodoL<E>newNodo= new NodoL<E>(element,trailer.getPrev(),trailer);
        trailer.getPrev().setPrev(newNodo);//quello che era il predecessore di trailer, adesso è il predecessore del nuovo nodo
        trailer.setPrev(newNodo);//imposto il nuovo predecessore di trailer
        size++;
    }
    
    //se aggiungo in un qualsiasi punto
    public void add(NodoL<E> node, E element)
    {
        NodoL<E> newNodo=new NodoL<E>(element,node.getPrev(),node.getNext());
        node.getPrev().setNext(newNodo);//il predecessore del vecchio nodo, avrà come successore il nuovo nodo
        node.setPrev(newNodo);
        size++;
    }
    
    //trovo il minimo
    public E minimo()
    {
        NodoL<E>aux=header.getNext();
        NodoL<E>min=aux;
        while(aux!=null)
        {
            if(aux.getElement().compareTo(min.getElement())<0)
                aux=min;
            aux=aux.getNext();
        }
        return min.getElement();
    }
        
    //cancello un nodo
    public void remove(NodoL<E> node)
    {
        NodoL<E> prev=node.getPrev();
        NodoL<E>next=node.getNext();
        prev.setNext(next);
        next.setPrev(prev);
        node.setPrev(null);
        node.setNext(null);
        size--;
    }
    
    public String toString()
    {
        String str="";
        NodoL<E>aux=first();
        while(aux!=trailer)
        {
            str+=aux.getElement()+" ";
            aux=aux.getNext();
        }
        return str;
    }
}


class NodoL<E>
{
    private E element;
    private NodoL<E>prev;
    private NodoL<E> next;
    
    public NodoL(E element, NodoL<E> prev, NodoL<E> next)
    {
        this.element=element;
        this.next=next;
        this.prev=prev;
    }
    
    public E getElement()
    {
        return element;
    }
    
    public void setElement(E element)
    {
        this.element=element;
    }
    
    public NodoL<E> getPrev()
    {
        return prev;
    }
    
    public void setPrev(NodoL<E> prev)
    {
        this.prev=prev;
    }
    
    public NodoL<E> getNext()
    {
        return next;
    }
    
    public void setNext(NodoL<E> next)
    {
        this.next=next;
    }
}

codice:
import java.io.*;
import java.util.*;

public class MStack<E>
{
	protected int capacità;//effettiva capacità dell'array
	public static final int maxCapacità=50;//numero massimo di elementi che può contenere
	private E[]set;//array per implementare lo stack
	private int top;//indice dell'elemento in cima allo stack
	
	public MStack()
	{
		this(maxCapacità);//capacità di default
	}
	
	public MStack(int cap)
	{
		capacità=cap;
		set=(E[]) new Object[capacità];
		top=0;
	}
	
	public boolean isEmpty()
	 {
		 return(top==0);
	 }
	 
	 public int size()
	 {
		 return(top+1);
	 }
	 
	//cancello dalla cima
	public E pop() throws EmptyStackException
	{
		if(isEmpty())
			throw new EmptyStackException("stack vuoto");
		else
		return set[--top];
	}
	
	//aggiungo in cime
	public void push(E element) throws FullStackException
	{
		if(size()==capacità)
			throw new FullStackException("stack pieno");
		else
		set[top++]=element;
	}
	
	public E getTop() throws EmptyStackException
	{
		if(isEmpty())
			throw new EmptyStackException("stack vuoto");
		else
		return set[top];
	}
}
codice:
import java.io.*;
import java.util.*;

public class mioStack<E extends Comparable> implements StackSet140910<E>
{
	private int stacks;
	private int items;
	LinkedList<E> lista;
	

	public mioStack()
	{
		stacks=0;
		items=0;
		lista=new LinkedList<E>();
	}
	
	//ritorna il numero di elementi(di tipo MStack<E>) dell'insieme
	public int stacks()
	{
		return stacks;
	}
	
	//ritorna il numero di elementi di tipo E dell'insieme
	public int items()
	{
		return items;
	}
	
	//ritorna il primo stack vuoto dell'insieme.se non esistono stack vuoti nell'insieme
	//ritorna lo stack con il più piccolo valore in testa
	public MStack<E> getMin()
	{
		MStack<E> ms=(MStack<E>)lista.first();//QUI MI DA ERRORE
		if(ms.isEmpty())//se è vuoto...
			return ms;//lo restituisce...altrimenti faccio un confronto per trovare il minore
		else
			return lista.minimo();//QUI MI DA UN ALTRO ERRORE
		
		
	}
	
	//effettua il pop sul primo stack dell'insieme
	public E pop()
	{
		E element=lista.first();//QUI MI DA ERRORE
		lista.remove(element);
		stacks--;
		return element;
		
	}
	public void push(E element)
	{
		lista.addFirst(element);
		items++;
	}
			
}
Come devo sistemare questi metodi?non capisco proprio :-(