Originariamente inviato da peruzzo
1)
Il codice seguente:
fr.read(buffer)
carica in un vettore di char di nome buffer i primi 1024 caratteri presenti nel file e sposta l'inizio delle letture sucessive nel file stesso alla fine del 1024-esimo carattere o i-esimo carattere con i<1024 se il file ha meno di 1024 caratteri. Al termine della procedura conta il numero di valori diversi da null e li salva nel valore primitivo byteLetti. E' esatto quello che scrivo?
Ni. E' giusto fino al primo "."
Molto più semplicemente, il metodo read(buffer) legge fino ad un massimo di buffer.length caratteri (ovvero, se buffer è un char[1024] legge fino ad un massimo di 1024 caratteri), i byte letti dal file vengono, ovviamente, portati dentro al vettore di caratteri (a partire dalla prima posizione) e il metodo restituisce il numero effettivo di byte letti (che può essere 1024 o meno, se il file termina prima). Viene, di conseguenza, spostato il puntatore di lettura del file dopo l'ultimo carattere letto.
Il ciclo while termina quando si raggiunge la fine del file e l'ultimo assegnamento a byteLetti genera un numero pari a -1 ovvero buffer con tutti valori pari a null ovvero fine della lettura del file. E' giusto anche questo?
Anche qui, parzialmente.
Il ciclo termina quando si raggiunge la fine del file, ovvero quando si tenta di leggere "oltre" la fine del file, il metodo non scrive nulla dentro al vettore e si limita a ritornare il valore "-1" (valore di ritorno che viene salvato nella variabile "byteLetti"), che indica, appunto, che non ci sono altri dati da leggere.
Stiamo lavorando con tipi primitivi, quindi non c'è niente che possa essere "null", né alcunchè da convertire.
2)
Hai creato un metodo try per la chiusura del file, per quale ragione? E' sbagliato chiudere fr nel primo try? (qui mi devi spiegare bene le ragioni della tua scelta...)
Veramente ho aggiunto la sezione "finally".
Il costrutto è il seguente:
codice:
try {
... // operazioni che possono sollevare eccezioni
} catch (XYZException e) {
... // Cattura dell'eccezione XYZException
} finally {
... // Operazioni da svolgersi SEMPRE, anche in caso di eccezioni
}
E' sempre consigliabile mettere le operazioni di chiusura dei file (ed, in generale, delle risorse) nel blocco finally in modo da assicurarsi che esse vengano eseguite sempre, anche nel caso vi siano state eccezioni. Non è corretto inserire la chiusura del file nel blocco try, poichè se viene sollevata un'eccezione, la chiusura potrebbe non essere effettuata:
codice:
try {
FileInputStream fis = ... // Apro il file
... // Uso il file
fis.close();
} catch (Exception e) {
...
}
Se viene sollevata un'eccezione nella parte in grassetto, l'esecuzione salta immediatamente all'area catch e la chiusura non verrà effettuata.
3)
Quali sono le differenze tra il sistema di LeleFT e quello che avevo pensato di usare ovvero il seguente:
...
e soprattutto quale dei 2 mi consigliereste di usare? (PRO e CONTRO di uno e dell'altro...)
Il mio metodo legge il file come se fosse una sequenza di caratteri, il tuo come se fosse una sequenza di "righe di testo". Dal punto di vista pratico, a parte l'uso di String e del consumo di memoria, non c'è alcuna differenza, dal punto di vista "concettuale" è una cosa diversa. Il mio metodo non fa alcuna supposizione sul contenuto del file, quel che c'è c'è e lo mangia; il tuo presuppone che vi siano linee di testo separate dal carattere di newLine, carattere che viene "soppresso" dalla lettura perchè si suppone non sia "un dato interessante". Ai fini pratici, l'uno e l'altro si equivalgono. Il mio potrebbe essere più efficiente, in quanto non viene fatta alcuna parserizzazione dei dati alla ricerca del newLine, quando questo viene trovato il mio non lo rimuove, tu poi lo vai ad aggiungere a mano... 
P.S.:LeleFT volevi scrivere "System.out.print(buffer[i]);" giusto?
Sì, ormai il println() mi va in automatico con le dita...
Ciao. 
Rispondi quotando
scommessa vinta! 
