C'è un esercizio in pò complesso, che mi sta dando qualche problema, volevo chiedere se avete del tempo l'aiuto per la risoluzione di alcuni errori...

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 programma consegnato dovrà compilare correttamente e dovrà
produrre il corretto output. In caso contrario la soluzione
verrà considerata errata.
Specifiche della classe
Qualsiasi struttura dati ausiliaria dovrà essere
implementata dallo studente.Il file di input contiene una sequenza di numeri interi, uno
per riga.
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.
Ecco l'interfaccia:

codice:
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
}
Quindi mi sembra di aver capito che io ho un insieme, una linkedlist, che è una collezione di stack, allora ho pensato di creare la classe nodo, MStack, dove MStack è implementato sempre tramite LinkedList, e poi di realizzare l'insieme che contiene gli MStack sempre in una linkedList dove per ogni nodo abbiamo un MStack.
Ho dei problemi rigurado alcuni metodi....posto il codice e alcuni degli errori:

Vi posto gli errori, che si verificano dove ho commentato nel codice //errore

codice:
SS7_003292.java:149: cannot find symbol
symbol  : method getSize()
location: interface java.lang.Comparable<E>
		items+=testa.getElement().getSize();  //primo errore, non trova il metodo getSize()
		                         ^
SS7_003292.java:149: inconvertible types
found   : <nulltype>
required: int
		items+=testa.getElement().getSize();  //primo errore, non trova il metodo getSize()
		                                 ^
SS7_003292.java:159: cannot find symbol
symbol  : method top()
location: interface java.lang.Comparable<E>
		E min=stackset.getHead().getElement().top();         //errore, non trova il metodo top()
		                                     ^
SS7_003292.java:163: cannot find symbol
symbol  : method getSize()
location: interface java.lang.Comparable<E>
			if(testa.getElement().getSize()==0)
			                     ^
Non capisco perchè...perchè cerca i metodi nell'interfaccia comparable? viene estesa dalla mia classe ma perchè non li cerca al posto giusto?

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

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
}

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

class LinkedList<E>
{
	private Node<E> head, tail;
	private int size;
	
	public LinkedList()
	{
		size=0;
		head=tail=null;
	}
	
	public Node<E> getHead(){return head;}
	
	public Node<E> getTail(){return tail;}
	
	public int getSize(){return size;}
	
	public void addNodeTail(Node<E> node) //inserimento in coda
	{
		if(size==0)
			tail=node;
		
		else
		{
			tail.setNext(node);
			tail=node;
		}
	    size++;
	}
	
	public void AddNodeHead(Node<E> node) //inserimento in testa
	{
		if(size==0)
			head=node;
		else
		{
			node.setNext(head);
			head=node;
		}
		size++;
	}
	
	public void removeHead()    //rimozione in testa
	{
		Node<E> tmp=head;
		head=head.getNext();
		head=null;
		size--;
	}
			
}

class MStack<E>
{
	private LinkedList<E> stack;           //lo implemento con linkedlist
	private int size;
	
	public MStack()
	{
		size=0;
		stack=new LinkedList();
	}
	
	public int getSize(){return size;}
	
	public void push(E element)
	{
		Node<E> node=new Node(element,null);
		stack.AddNodeHead(node);
		size++;
	}
	
	public void pop()
	{
		stack.removeHead();
		size--;
	}
	
	public Node<E> top()
	{
		Node<E> tmp=stack.getHead();
		return tmp;
	}
}

class InsiemeStackSet140910<E extends Comparable<E>> implements StackSet140910<E>
{
	LinkedList<E> stackset;
	private int size;
	
	public InsiemeStackSet140910()
	{
		size=0;
		stackset=new LinkedList();
	}
	
	public int stacks(){return size;}
	
	public int items ()
	{
		int items=0;
		
		Node<E> testa;
		
		for(testa=stackset.getHead(); testa!=null; testa=testa.getNext())
		items+=testa.getElement().getSize();  //primo errore, non trova il metodo getSize(), non capisco perchè, con l'istruzione prima dovrebbe accedere all'MStack, perchè non trova il metodo e lo cerca da un'altra parte?
		
		return items;
	}
	
	public MStack<E> getMin ()
	{
		Node<E> testa;
		
		MStack<E> tmp;
		E min=stackset.getHead().getElement().top();         //errore, non trova il metodo top()
		
		for(testa=stackset.getHead(); testa!=null; testa=testa.getNext())
		{
			if(testa.getElement().getSize()==0)         //anche qui non trva getSize()
			{
				tmp=testa.getElement();
				return tmp;
			}
			
			else if(min.compareTo(testa.getElement().top())>0)
				min=testa.getElement().top();
		}
		
	    return min;
	}
	
	public E pop ()
	{	size--;
		E tmp=stackset.removeHead();
		return tmp;
	}
	
	public void push(E element)
	{
		stackset.getHead().getElement().addNodeHead(Node<E> node);
		size++;
	}
	
	public void addStack ()
	{
		MStack<E> nuovostack=new MStack();
		Node<E> node=new Node(nuovostack,stackset.getHead());
		stackset.addNodeHead(node);
	}
	
	//public Iterator<E> iterator();
// ritorna un iteratore di tutti gli elementi (di tipo E)
// contenuti negli stack dell'insieme
	
}

/*class ElementsIterator<E> implements Iterator<E>
{
	private LinkedList<E> listIterator;
	private LinkedList<E> support;
	private Node<E> cursor;
	
	public ElementsIterator()
	{
		listIterator=new LinkedList();
	}
	
	support=new LinkedList();
	Node<E> tmp;
	
	for(tmp=listIterator.getHead(); tmp!=null; tmp=tmp.getNext())
	support.addNodeHead(tmp);
	
	if(support.getHead()==null)
		cursor=null;
	else cursor=support.getHead();
	
	public boolean hasNext()
	{
		
	*/