PDA

Visualizza la versione completa : [java]leggere file


giof50
08-09-2004, 15:16
Ho necessità di leggere un file scritto in esadecimale e del quale ho bisogno di esaminare carattere per carattere o perlomeno riuscire a posizionarmi a determinate posizioni.
Ho provato nel seguente modo ma sicuramente sbaglio.....
FileReader fr ;

String tmp1= PathInput + name;
String s = new String();
String scmd = new String();

try {fr=new FileReader(tmp1);}
catch (IOException ed) {fr=null;};


BufferedReader br = new BufferedReader(fr);

do
{
//try {s=br.readLine();
try {numletti=br.read(cbuf,1,10);
if (numletti==0)
{
break;
}
else
{

System.out.println("LEGGO " + cbuf);
}
} catch (IOException ea){System.out.println("ERRORE");};

}while(s != 0);
return true;
}
Non riesco nenache a dichiarare cbuf in modo corretto.
Aiuto!!

LeleFT
08-09-2004, 16:36
Non ho ben capito cosa intendi fare, se leggere il contenuto del file, o cos'altro...
Penso che tu voglia leggere il contenuto del file, quindi c'eri quasi, solo che hai fatto molte operazioni in più inutili:


FileReader fr;
BufferedReader br;
String tmp1= PathInput + name;
String s = null;
String scmd = null;

try {
fr = new FileReader(tmp1);
br = new BufferedReader(fr);
do {
s = br.readLine() // in s hai il contenuto della prima linea
if (s != null) {
System.out.println("Ho letto: " + s);
} else {
System.out.println("FINE DEL FILE");
}
} while (s != null);
} catch (Exception e) { e.printStackTrace(); }

Innanzitutto ti consiglio di usare solamente un blocco try/catch, così se accade un'eccezione in qualsiasi parte del codice la catturi, senza bisogno di differenziare così tanto il punto (il compilatore, infatti, ti dice esattamente la riga in cui si è verificata l'eccezione).

Tu devi esaminare ogni riga, carattere per carattere. Quindi puoi procedere in questo modo:


do {
s = br.readLine();
if (s != null) {
for (int i=0; i<s.length(); i++) {
System.out.println("Carattere numero " + i + ": " + s.charAt(i) );
}
}
...
} while (s != null);


Il fatto che tu legga delle stringhe che rappresentano dei numeri in base 16 penso che ti serva per poterle trattare come numeri. In questo caso, la classe Integer ti mette a disposizione il metodo parseInt() che può parsare anche stringhe di numeri in base diversa dalla 10:


String mioNumero = "B902";
System.out.println("Valore decimale: " + Integer.parseInt(mioNumero, 16) );


Ciao. :ciauz:

giof50
09-09-2004, 11:22
Grazie dell'aiuto con il quale sono andato più avanti, ma ora ho difficoltà ad utilizzare "read", ossia devo leggere un certo numero di caratteri alla volta posizionandomi in detgerminate posizioni (ho provato skip ed è ideale).
Soprattutto non riesco a dichiarare e quindi ad utilizzare cbuf della
read(cbuf,int,int).
Grazie!!! :ciauz: :ciauz:

LeleFT
09-09-2004, 11:40
Se vuoi utilizzare la versione di read che prende i tre parametri:


int read(char[] cbuf, int offset, int length);

Puoi procedere così:


int num = 0;
int quanti = 10; // Così leggo 10 caratteri alla volta;
int offset = 0;
char [] cbuf = new char[quanti];
do {
...
num = br.read(cbuf, offset, quanti); // Leggo 'quanti' caratteri a partire da 'offset' e li memorizzo in 'cbuf'
offset += num; // Incremento l'offset.
for (int i=0; i<cbuf.length; i++)
System.out.println(cbuf[i]);
...
} while (num > -1);

In questo modo, ciascun carattere letto viene salvato in un elemento dell'array di caratteri cbuf.


Ciao. :ciauz:

giof50
09-09-2004, 13:08
Indicazioni perfette , ma è possibile che ciclando nelle letture quello che loggo si accoda (nel buffer) a quello letto precedentemente?
O più precisamente come faccio a pulire il buffer?
:ciauz: :nonono:

LeleFT
09-09-2004, 13:45
Secondo il codice che ti ho dato non dovrebbe accodarsi il nuovo input, al vecchio, ma sovrascriverlo ad ogni lettura (tranne, forse, la lettura finale), dato che il buffer ha la stessa dimensione dell'input. Se vuoi evitare problemi di accodamento, basta che tu ricostruisca ad ogni ciclo il buffer:


int num = 0;
int quanti = 10; // Così leggo 10 caratteri alla volta;
int offset = 0;
char [] cbuf;
do {
...
cbuf = new char[quanti];
num = br.read(cbuf, offset, quanti); // Leggo 'quanti' caratteri a partire da 'offset' e li memorizzo in 'cbuf'
offset += num; // Incremento l'offset.
for (int i=0; i<cbuf.length; i++)
System.out.println(cbuf[i]);
...
} while (num > -1);

La linea in grassetto ricostruisce il buffer prima di utilizzarlo. In questo modo hai sempre un buffer pulito.

Ciao. :ciauz:

Loading