Leggere un file data una precisa posizione

[soeca]

Ragazzi qualcuno mi potrebbe spiegare come si può leggere un file partendo da una precisa posizione??Mi spiego meglio: io vorrei leggere un file per esempio partendo dalla quinta riga e trascurando le precedenti!!I metodi della classe BufferedReader e FileReader come mi posso aiutare in questo???io avevo pensato( ovviamente sbagliando perchè l'ho provato e non fa assolutamente quello che voglio io!!) di scrivere if((c=in.read())== 5) come condizione per leggere la quinta riga(ho pensato questo perchè ho pensato se il -1 corrisponde al EOF e l'EOF si trova nell'ultima riga, vuol dire che -1 è l'ultima riga e quindi se gli do 5 leggerà dalla quinta riga!!.....ma non è andata per niente così!!)Allego un programma di prova che ho scritto in modo da capire come si può fare ed eventualmente implementare questa soluzione in un altro programma che sto facendo!!

import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedReader;
import java.io.BufferedWriter;
public class LeggiRiga 
{
	public static void main(String args[]) throws Exception
	{
		FileReader in=null;
		FileWriter out=null;
		BufferedReader br=null;
		BufferedWriter bw=null;
		try
		{
			
			String str;
			in=new FileReader("prova.txt");
			out=new FileWriter("output.txt");
			br=new BufferedReader(in);
			bw=new BufferedWriter(out);
			int c=in.read();
			while((str=br.readLine())!=null)
			{	
				if(c== 5)
					bw.write(str);
					bw.newLine();
				
			}
		}
		catch(Exception e)
		{
			
			System.out.print("Exception");
		}
		finally
		{
			br.close();
			bw.close();
			in.close();
			out.close();
			System.out.println("**** DONE ****");
		}
	}
}

PS. Lasciate stare il catch perchè visto che è un programma di prova e non scatena alcuna eccezione allora non mi interessava scrivere in dettaglio il modo per catturare le eccezioni!!
Grazie a tutti!!!

[LeleFT]

No, se il file di testo non ha una struttura molto precisa e sempre identica, l'unico modo per poter "leggere a partire da una data riga" è quella di "leggere a vuoto" tutte le righe precedenti.

E per farlo dovrai tenere un contatore:

BufferedReader br = new BufferedReader( ... );
String linea = "";
int numeroRiga = 0;

while((linea = br.readLine()) != null) {
   numeroRiga++;
   if (numeroRiga >= 5) {
      // Qui entro solo se ho letto una riga dalla 5° in poi
      ...
   }
}

Ciao.

[soeca]

Grazie per la risposta.......però........ora sono + confuso di prima!! mi spiego:io ho un file di testo di input composto nel seguente modo:

4x9
1 5 9 8 2 8 7 4 8
6 7 5 7 2 9 0 9 1
2 2 9 0 9 0 1 6 0
2 5 2 1 6 7 0 7 1

9x6
6 7 8 2 4 5
1 6 4 1 7 5
5 2 7 6 1 9
9 0 2 1 5 4
4 4 4 4 1 7
4 7 7 2 2 1
7 5 0 4 7 7
1 4 9 8 2 3
0 1 3 2 5 0

6x4
9 4 4 6
5 2 0 5
1 3 9 2
2 4 2 6
3 2 8 8
1 8 2 4

4x4
4 9 2 1
0 3 0 4
7 8 2 1
9 9 2 4

l'esercizio mi dice di leggere queste matrici, fare la somma di tutti i numeri all'interno di ogni singola matrice(per esempio dell'ultima matrice il valore somma è 65 ottenuto sommando tutti i numeri al suo interno!)e poi stampare in un file di output tutte le matrici riordinate in base al loro valore somma!!Io ho scritto un metodo Leggi che però non so come completare perchè non riesco a leggere tutte le matrici successive alla prima, perchè tra una matrice e un'altra c'è una riga vuota e una riga che mi indica le dimensioni della matrice successiva!!Questo è il mio codice:

public void Leggi(int pos) throws IOException
	{
		
		FileReader file=new FileReader("prova.txt");
		BufferedReader br=new BufferedReader(file);
		String str;
		int contaMatrici=0;
		while ((str=br.readLine())!=null)
		{	
			//Creo la matrice con le corrette dimensioni
			for(int i=0;i<str.length();i++)
			{
				if(str.charAt(i)=='x')
				{
					righe=(Integer.parseInt(str.substring(0,i)));
					colonne=(Integer.parseInt(str.substring(i+1,str.length())));
					matrice=new int[righe][colonne]; 
					contaMatrici++;
				}
			}
			//Riempiamo la matrice
			for(int i=0;i<str.length();i++)
			{
				for(int j=0;j<str.length();j++)
				{
					matrice[i][j]=(int)str.charAt(j);
					contoElementi+=matrice[i][j];
				}
				position=pos+1;
			}
			if(position == righe)
			{
//			???Devo trovare il modo di leggere il file da una determinata posizione perchè vorrei usare la ricorsione                 //facendo Leggi(position);
			}
		}
	}

Se c'è qualcosa che non è chiara del codice fatemelo sapere!!
PS. Ovviamente le matrici non sono solo queste 4 ma il file di input ne è pienissimo....ho riportato solo queste 4 per farvi capire meglio cosa richiede il testo dell'esercizio che non riesco a fare!!

[satifal]

Stai effettuando un'operazione assolutamente sequenziale, come la lettura di un file, per cui dubito che tu possa utilizzare la ricorsione. Secondo me dovresti semplicemente scorrere il file dall'inozio alla fine e man mano che individui le matrici effettuare le operazioni di somma.

[soeca]

il mio problema è proprio il " man mano che individui le matrici" !!!!cioè come faccio allora ad individuare le matrici???

[satifal]

La cosa più semplice ed immediata che mi viene in mente, se la struttura del file è sempre quella da te descritta, è quella di scorrere il file dall'inizio. La prima riga valorizzata indica le dimensioni della matrice che segue, per cui dopo averla letta sai che la matrice seguente sarà, ad esempio, nxm per cui le successive n righe conterranno i valori della matrice, a seguire triverai nuovamente l'indicazione delle dimensioni della matrice successive, n1xm1 per cui le successive n1 righe conterranno i dati della matrice e così via. Devi semplicemente lavorare con contatori ed indici.

[andbin]

Originariamente inviato da soeca
il mio problema è proprio il " man mano che individui le matrici" !!!!cioè come faccio allora ad individuare le matrici???

E io che cosa ti avevo risposto in questa tua discussione?

Di fare una classe es. LettoreFileMatrici (ma poi chiamalo come ti pare, ovviamente) che si tiene internamente come variabile di istanza il BufferedReader e poi un metodo es.

public Matrice leggiMatrice() throws IOException

Il metodo deve banalmente fare le seguenti operazioni sequenziali:

1) Finché leggo righe "vuote" le scarto.
2) La prima riga non vuota si presuppone sia quella che descrive il formato della matrice come NxM
3) Sapendo il numero di righe, si leggono ulteriori N righe.
4) Stop, si restituisce l'oggetto Matrice che ovviamente deve essere stato "popolato" nel ciclo di lettura delle N righe.

Se non è possibile fare questa lettura (es. si è subito a end-of-file o ci si arriva magari avendo letto solo righe vuote) si può restiture un bel null. Per altri errori si lanciano eccezioni.

Fatto questo dovresti intuire subito che poi leggere X matrici è banale, ogni volta che invochi leggiMatrice() lui riparte con il BufferedReader dal punto e nello stato rimasto dall'ultima lettura precedente!

[soeca]

Scusate se la cosa potrà sembrarvi di una banalità atroce.......però in termini di codice come faccio a dire "finchè leggo righe vuote"???la riga vuota non è caratterizzata dall'avere in prima posizione "\n"???se si allora potrebbe andare bene scrivere: while((str=br.readLine())!="\n") ???Grazie ragazzi per l'aiuto!!

[valia]

Originariamente inviato da soeca
Scusate se la cosa potrà sembrarvi di una banalità atroce.......però in termini di codice come faccio a dire "finchè leggo righe vuote"???la riga vuota non è caratterizzata dall'avere in prima posizione "\n"???se si allora potrebbe andare bene scrivere: while((str=br.readLine())!="\n") ???Grazie ragazzi per l'aiuto!!

intanto ti consiglio (per questioni di debug e leggibilità del codice) di separare la riga in cui fai la readLine() dal ciclo. Ne dovrai aggiungere un'altra come ultima istruzione del ciclo, ma ne guadagni in leggibilità.
Ammesso fosse corretta, è meglio scrivere

str = br.readLine();
while(str !="\n")

ora guardiamo al secondo errore: in java (e non solo) le stringhe sono OGGETTI che si confrontano tramite il metodo equals (che qualcuno ha già scritto al posto tuo)

str = br.readLine();
while(!str.equals("\n"))

anche se \n può essere considerato un carattere singolo e quindi il confronto può essere fatto in altro modo

str = br.readLine();
while(str != null && str.length() > 0 && str.charAt(0) != '\n')

può anche andar bene (controlli se hai una stringa valida, se hai scritto almeno il carattere \n e se devi andare avanti.

prova così e poi si vede

[andbin]

Originariamente inviato da soeca
while((str=br.readLine())!="\n") ???Grazie ragazzi per l'aiuto!!

NO. readLine NON mette nella stringa restituita la sequenza di newline (\r\n o \n o \r).

Quindi:

String linea;

do {
    linea = br.readLine();
} while (linea != null && linea.trim().length() == 0);

// Qui usa linea ... se null vuol dire che sei end-of-file, se non null hai la prima riga non "vuota".