[java] eliminare "a capo" errati

[Pierock]

salve ragazzi,
ho un piccolo problema, devo leggere dei numeri da un file di testo, ma in questo file gli "a capo" sono posizionati in maniera errata...
ad esempio

8,0113  8,1775  8,2065  8,2225  8,2395  8,2433  8,2289  8,1
 875  8,1307  8,1188  8,0778  8,0492  8,0803  8,1813  8,2242
8,2287  8,2570  8,3215  8,4314  8,5572  8,5648  8,4827  8,4486 
8,4736  8,5628  8,7792  8,8967  8,8288  8,5731  8,4651  8,6062  8,
8632  8,9893  9,2205  9,3411  9,6017  9,8768  9,9807
 11,8953  11,8237  11,7309  -11,5268  11,4476  11,4063  -
11,4113  11,4110  11,4320

inizialmente utilizzavo un BufferedReader, invocavo una readLine(), e splittavo sugli spazi, ma mi sono accorto che in questo modo ottenevo dei risultati errati; in quanto, prendendo ad esempio il caso specifico, otterrei il numero
8,1 e poi un 875 ... al posto del 8,1875
..
pensavo di fare una sorta di pre-parsing del file per eliminare tutti i pattern "a capo+spazio" .. e poi avviare la vecchia analisi... come posso fare?

[Alex'87]

Leggi il file con readLine() ed ogni riga la aggiungi, trimmata, ad uno StringBuffer/StringBuilder (a seconda se ti serve thread safe o meno). Una volta che hai la stringa completa puoi splittare sullo spazio.

[Pierock]

Ciao Alex, ti rispondo con un abisso di ritardo... perdonami
torno solo ora a dovermi rioccupare di questo problemino..
..
l'idea del trim() sembrerebbe poter funzionare, anche se ho un paio di perplessità...
innanzitutto preciso che stando alle ultime... il pattern che avevo ipotizzato "a-capo + spazio" non è sempre valido..
per quanto riguarda le perplessità...
potrei ritrovarmi in casi come questo:

 
8,2287  8,2570  8,3215  8,4314  8,5572  8,5648
     8,9893  9,2205  9,3411  9,6017  9,8768

in questo caso ... unendo le due stringhe "trimmate" otterrei questo "8,56488,9893"
credo che a questo punto mi converrebbe fare una specie di parser!? .. o ho delle altre alternative?

... un'ulteriore domanda...
ho provato a scrivere un piccolo metodo per dare un "a capo" ad ogni spazio, ignorando gli invio già nel file:

		String DirectoryDtm = "file";
			try {
				InputStream file = new FileInputStream(DirectoryDtm); // DIRECTORY DEL FILE
				FileOutputStream prova = new FileOutputStream("fileOutput");
				PrintStream scrivi = new PrintStream(prova);
				char c;
				boolean find = false;
				while(!find){
				c = (char)file.read();
				if(c==' ' && (c!='\n'||c!='\r'))
					scrivi.print('\n');
				else
					scrivi.print(c);
				if(c == (char)-1){
					find = true;
				}
				}


				}  catch(IOException s)
				   {
						s.printStackTrace();
				   }

.. eseguendo... di fatto mi crea gli invio al posto degli spazi... ma mantiene quelli già presenti, nonostante i controlli sui caratteri '\n' e '\r' ..
.. dove sbaglio?

tnks

[Pierock]

...ok,
pardon ... iniziamo con il fatto che l'IF l'ho scritto con i piedi...
correggo:

	if(c==' ')
					scrivi.print('\n');
				else
					if(c!='\n' && c!='\r')
					scrivi.print(c);

[zipangulu]

Non vorrei dire baggianate ma ciacun numero mi sembra scritto nella stessa forma o meglio dire per quanto riguarda la parte decimale (4 cifre decimali)..se è vera questa ipotesi, potresti fare una cosa del genere:

StringBuilder sb = new StringBuilder ();
BufferedReader br = new BufferedReader (new InputStreamReader (new FileInputStream ("file.txt")));
String s;
while ((s = br.readLine ()) != null) {
    sb.append (s);
}
s = sb.toString ().replaceAll (" " , "");
int j;
while ((j = s.indexOf (",")) < s.length () && j >= 0) {
   System.out.println (s.substring (0 , j + 5));
   s = s.substring (j + 5);
}

Ovviamente adattalo alle tue esigenze.

[Pierock]

si zipangulu , anche io stavo procedendo in questo senso .. effettivamente è l'unico pattern ricorrente,
quattro cifre significative dopo la virgola...
cercavo di fare un po' la stessa cosa ma analizzando carattere per carattere... un po' come avevo accennato sopra...
la tua idea di utilizzare gli indexOf e substring mi sembra molto elegante... ed in effetti funziona molto bene..

c'è un problema però .. il file di input è composto da circa 50mila righe se non di più... quindi il creare un unico StringBuilder iniziale forse è poco performante...
infatti per il file in questione il programma ci mette davvero molto a terminare...
bisognerebbe effettuare il secondo while riga per riga... considerando eventuali sottostringhe che rappresentano numeri parziali...

[Pierock]

zipangolu .. credo di aver risolto ...
ti scrivo la porzione di codice.. nel caso in cui qualcuno voglia fare qualche osservazione o miglioria...
tnks

StringBuilder sb = new StringBuilder();
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(
					new FileInputStream("file.txt")));
			FileOutputStream out = new FileOutputStream("fileOutput.txt");
			PrintStream scrivi = new PrintStream(out);
			String s;


			int alarm = 0;
			while ((s = br.readLine()) != null) {
				alarm++;
				sb.append(s);
				s = sb.toString().replaceAll(" ", "");
				int j;
				boolean smezza = false;
				while ((j = s.indexOf(",")) < s.length() && j >= 0 && !smezza) {
					scrivi.println(s.substring(0, j + 5));
					s = s.substring(j + 5);
					if (s.length() <= 12) 
						smezza = true;
				}
				sb.delete(0, sb.length());
				sb.append(s);


				System.out.println("w- " + s);
			}
			if (sb.toString().length() != 0)
				scrivi.println(sb.toString());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}


		System.out.println("finito");

[zipangulu]

Sinceramente la tua ultima implementazione non mi sembra poi così efficiente!
Innanzitutto perchè effettui una scrittura su file per ogni numero , poi mi sembra che il tuo procedimento sia un po' troppo elaborato.
Per i problemi di sopra potresti risolvere inserendo ogni numero in un StringBuilder (dopo ogni numero ci metti un "a capo" , tranne magari per l'ultimo, per imitare lo scrivi.println di ogni numero) e scrivi in un unica volta l'intero file con sb.toString ()
La procedura da me prima postata può essere migliorata , come tu avevi fatto notare , nel seguente modo:

BufferedReader br = new BufferedReader (new InputStreamReader (new FileInputStream ("file.txt")));
String s;
String s1 = "";
int j;
while ((s=br.readLine ())!=null) {
   s1+=s.replaceAll (" ","");
   while ((j=s1.indexOf (",")) < s1.length () /*&& j>= 0*/ && (j+5) <= s1.length ()) {
      System.out.println (s1.substring (0 , j + 5));
      s1 = s1.substring (j + 5);
   }
}

Io nel mio esempio procedo alla stampa su console , per il tuo caso (scrittura su file) dovresti sostituire i miei println (stringa) in sb.append (stringa + "\n") , il "\n" se non vuoi un "a capo finale lo levi con un controllo apposito , e poi procedi con uno scrivi.println (sb.toString ()) finale..

Ps. il codice non l'ho rigorosamente testato e controllato causa rincoglionimento da studio universitario profondo quindi stai attento a eventuali errori

[Pierock]

ciao zip, effettivamente hai ragione...
per quanto concerne la scrittura su file .. non è una cosa essenziale ai fini del problema, è una cosa che ho inserito io tanto per avere la possibilità di leggere i dati evitando i sysout ... altrimenti, considerando le 150mila cifre ci avrebbe messo molto più tempo e non avrei potuto dare una visione di insieme...
fatto sta che ti assicuro farò tesoro del tuo consiglio !!! (non ci avevo pensato)

per il resto ... effettivamente .. come avevo sospettato... avevi in serbo per me una versione un po' più elegante del mio metodo
ad un primo sguardo sembrerebbe corretto .. anche se credo manchi un ultimo print all'uscita dal while ... cosa che farebbe perdere l'ultimo numero...

cmq sia...
lo testo più tardi... ti lascio al tuo rincoglionimento da studio e nn ti rubo altro tempo
.. ti tengo aggiornato !

grazie ancora!