Ah ok, ora funziona la lettura, con il metodo trim() della classe String allora elimino gli spazi, buono a sapersi.
Perņ il programma non funziona....mi dą sempre nullpointerException, non gli vanno bene gli inserimenti, provo a ricontrollarlo, eventualmente, potresti dirmi se riesci a riscontrare dove sono gli errori?
Praticamente ho un' interfaccia, e devo implementarla tramite una classe di tipo albero binario, il quale č costituito da nodi, contententi oggetti di tipo Coppia, formati da due interi.
Il codice č:

L'interfaccia č:
codice:
public interface IterativeBST<E> {
public int size ();
// ritorna il numero di nodi dell'albero
public void insert (E x);
// inserisce un nuovo elemento nell'albero
public boolean search (E x);
// ritorna true se l'elemento E č contenuto nell'albero
public void RightRotate(E x);
// effettua una rotazione destra sul nodo che contiene x
public E succesor(E x);
// ritorna l'elemento successivo di x
}
Classe Nodo del grafo:

codice:
public class TNode<E /*extends Comparable*/>
{
	private E element;
	private TNode<E> parent, left, right;
	
	public TNode(E element)
	{
		this.element=element;
		parent=null;
		left=null;
		right=null;
	}
	
	//public void setElement(E element){this.element=element;}
	
	public E getElement(){return element;}
	
	public void setParent(TNode<E> parent){this.parent=parent;}
	
	public TNode<E> getParent(){return parent;}
	
	public void setLeft(TNode<E> left){this.left=left;}
	
	public TNode<E> getLeft(){return left;}
	
	public void setRight(TNode<E> right){this.right=right;}
	
	public TNode<E> getRight(){return right;}
	
	public boolean hasLeft(){return left!=null;}
	
	public boolean hasRight(){return right!=null;}
	
}
classe LinkedList, che implementerą l'albero:

codice:
public class TLinkedList<E>
{
	private TNode<E> head, tail;
	private int size;

	public TLinkedList()
	{
		head=tail=null;
		size=0;
	}
	
	public int getSize(){return size;}
	
	public TNode<E> getHead(){return head;}
	
	public TNode<E> getTail(){return tail;}
	
	public void addNode(TNode<E> node){ //inserisco confrontando le coppie, una coppia č maggiore di un' altra se la somma dei due interi č maggiore di quella dell'altra coppia, e non posso essere mai uguali
		if(size==0){
			head=node;
			tail=head;
		}
		else {
			boolean inserito=false;
			TNode<E> current=head;
			
			while(!inserito)
			{
				if(((Coppia)current.getElement()).compareTo(((Coppia)node.getElement()))<0)
				{
					if(!(current.hasRight()))
					{
						current.setRight(node);
						node.setParent(current);
						inserito=true;
					}
			
					else current=current.getRight();
				}
				
				else if(((Coppia)current.getElement()).compareTo(((Coppia)node.getElement()))>0)
				{
					if(!(current.hasLeft()))
					{
						current.setLeft(node);
						node.setParent(current);
						inserito=true;
					}
				}
				
				else current=current.getLeft();
			}
		}
	}
}
Classe coppia:

codice:
public class Coppia<E>
{
	int primo, secondo;
	
	public Coppia(int primo, int secondo)
	{
		this.primo=primo;
		this.secondo=secondo;
	}
	
	public int compareTo(Coppia<E> coppia){ //le coppie non sono mai uguali
		int somma1=getPrimo()+getSecondo();
		int somma2=coppia.getPrimo()+coppia.getSecondo();
		
		if(somma1<somma2) return -1;
		
		else return 1;
	}
	
	public int getPrimo(){return primo;}
	
	public int getSecondo(){return secondo;}
}
Classe Albero che implementa l'interfaccia:

codice:
public class BSTree<E>  implements  IterativeBST<E>
{
	private TLinkedList<TNode<E>> albero;
	private int size;
	private TNode<E> root;
	
	public BSTree()
	{
		root=null;
		size=0;
		albero=new TLinkedList();
	}
		
	public int size(){return size;}
	
	public TNode<E> getRoot(){return root;}
	
	public void insert(E node){
		((TLinkedList)albero).addNode((TNode)node);
		size++;
	}
	
	public boolean search (E node){
		TNode<E> current=getRoot();
		boolean trovato=false;
		
		while(!trovato && current!=null)
		{
			if(current.equals((TNode)node)){
				trovato=true;}
			
			else if(((Coppia)current.getElement()).compareTo(((Coppia)((TNode)node).getElement()))<0){
				current=current.getRight();}
				
			else current=current.getLeft();
		}
		
		return trovato;
	}
	
	public void RightRotate(E node){
		if(node==null) return;
		if(((TNode)node).getLeft()==null) return;
		
		TNode<E> y=((TNode)node).getLeft();
		y.setParent(((TNode)node).getParent());
	}
	
	public E succesor(E node){
		TNode<E> toReturn=((TNode)node).getRight();
		return (E)toReturn;
	}
	
	public String toString(){
		String s="";
		TNode<E> max=getRoot();
		while(max.hasRight())
			max=max.getRight();
		
		s+=max.getRight();
		
		return s;
	
	}
}
E il main:

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

public class Main
{
	FileReader reader=null;
	StringTokenizer str;
	PrintWriter out=null;
	BufferedReader buff=null;
	
	public void Costruiscialbero(String input, String output)
	{
		try{
			reader=new FileReader(input);
			buff=new BufferedReader(reader);
			out=new PrintWriter(output);
			
			BSTree<TNode> albero=new BSTree<TNode>();
			
			while(buff.ready())
			{
				//str=new StringTokenizer(buff.readLine(),"(,)");
				str=new StringTokenizer(buff.readLine().trim(),"(,)");

				
				int primo=0;
				int secondo=0;
				
				while(str.hasMoreElements())
				{
					primo=(Integer.parseInt(str.nextToken()));
					secondo=(Integer.parseInt(str.nextToken()));
				}
				
				Coppia coppia=new Coppia(primo, secondo);
				TNode<Coppia> nodo=new TNode<Coppia>(coppia);
				
				albero.insert(nodo);
				
			}
			
			albero.toString();
		      }
			
			catch(FileNotFoundException e1)
			{
				System.out.println("Error...file not found");
			}
		
			catch(IOException e2)
			{
				System.out.println("Error...input/output");
			}
			
			finally{
				try{
					
					buff.close();
					reader.close();
					out.close();
				      }
				      
				      catch(IOException e3){
					      System.out.println("Error...it is not possible to close files");
				      }
			      }
	}
	
	public static void main(String [] args)
	{
		Main main=new Main();
		long start=System.currentTimeMillis();
		main.Costruiscialbero("input.txt", "output.txt");
		long end=System.currentTimeMillis();
		System.out.println("Il tempo d'esecuzione č "+(end-start)+" ns");
	}
}
Gli errori sono:

codice:
Exception in thread "main" java.lang.NullPointerException
	at BSTree.toString(BSTree.java:57)
	at Main.Costruiscialbero(Main.java:42)
	at Main.main(Main.java:73)
>Exit code: 1
Nel toString di BSTree..all'istruzione

codice:
while(max.hasRight())
Non capisco perchč...