Come leggere da un file locale in java

Un file locale è nel disco rigido o un'unità flash collegata alla porta USB. I file possono essere classificati in due categorie: file di testo e file byte. I file di testo tipici sono file creati da un editor di testo. Il file di immagine è un esempio di un file di byte costituito principalmente da byte RAW.

Questo articolo fornisce una spiegazione di base su come leggere i file di testo e byte locali in Java. Per leggere un file di testo, utilizzare la classe, FileReader. Per leggere un file byte, utilizzare la classe, fileinputstream. Entrambe le classi sono nel Java.io.* pacchetto, che dovrebbe essere importato. La prima metà di questo articolo si occupa della lettura di file di testo e la seconda metà si occupa della lettura dei file di byte.

Leggere i file di testo

Costruire un oggetto FileReader

Prima di imparare come costruire un oggetto FileReader, creare il seguente file di testo, con un editor di testo e premere il tasto Invio alla fine delle prime due righe:

Un testo 1 a testo 1 a testo 1 a testo 1 a testo 1
B testo 2 b testo 2 b testo 2 b testo 2 b testo 2
C Testo 3 C Testo 3 C Testo 3 C Testo 3 C Testo 3

Se il tasto ENTER non viene premuto alla fine dell'ultima riga, l'editor di testo può aggiungere una nuova linea quando il file viene salvato. Dopo aver prodotto il testo precedente, salva il contenuto, con il nome temp.txt, utilizzando il menu dell'editor di testo, utente@host: ~/dir1 $, nella directory. Ciò significa che la directory, dir1, avrebbe dovuto essere creata.

Costruire un lettore di file

La classe FileReader ha cinque costruttori. Solo uno è illustrato in questo articolo (al fine di mantenere l'articolo breve). La sintassi per il costruttore è:

Public FileReader (String FileName) lancia FileNotFoundException

Questo è creato nella memoria un flusso (copia) del file, il cui percorso e nome è la stringa, nome file. Lancia un FileNotFoundException se il file non viene trovato nella directory indicata. Dopo aver copiato il contenuto del file, l'oggetto file aperto deve essere chiuso per rilasciare tutte le risorse di sistema associate al file aperto.

Metodi importanti di FileReader

Se il costruttore viene creato correttamente, il file viene considerato aperto. Dopo aver usato il file, il file deve essere chiuso. La sintassi per chiudere un file è:

public void Close () lancia ioException

Dopo che il file è stato appena aperto, non si è ancora verificata una lettura efficace del file. Per leggere un carattere alla volta (uno poi successivo), impiega la sintassi del metodo FileReader:

public int read () lancia ioException

Questo restituisce il carattere (come intero) letto o -1 se è stata raggiunta la fine del flusso (flusso di copia del file in memoria).

Per leggere la sequenza successiva di caratteri del file, in un array, impiega la sintassi del metodo FileReader:

public int read (char [] cbuf, int off, int len) lancia ioexception

Restituisce il numero di caratteri letti o -1 se è stata raggiunta la fine del flusso. Off nella sintassi significa offset. È l'indice nel file in cui è iniziata la lettura della seguente sequenza di caratteri. Len è il numero di caratteri da leggere. Dovrebbe essere la lunghezza dell'array, mentre CBUF è l'array in cui viene letta la sequenza di caratteri.

Ricorda che l'oggetto FileReader deve essere chiuso con il suo metodo vicino dopo questa lettura efficace.

La sintassi del metodo, per sapere se la lettura successiva non restituirà -1, è:

public boolean ready () lancia ioexception

Restituisce vero se c'è qualcosa da leggere e falso altrimenti.

Leggere in una stringa

Il seguente codice, legge il file precedente, caratteri per carattere, in una stringa stringa:

StringBuilder SB = new StringBuilder ();
Tentativo
FileReaderFr = new FileReader ("DIR1/TEMP.TXT");
mentre (fr.pronto())
char ch = (char) fr.Leggere();
sb.append (ch);


catch (eccezione e)
e.getMessage ();

Sistema.fuori.println (SB);

Il codice inizia con l'istanziazione di un oggetto StringBuilder, SB. Quindi, c'è il costrutto di cattura. Il blocco del tentativo inizia con l'istanziazione del fileReader, fr. E c'è il while-loop, che itera fino a quando è pronto () restituisce falso. La prima affermazione nel while-loop legge e restituisce il personaggio successivo come un numero intero. Deve essere scelto per Char. L'istruzione successiva nel circuito while aggiunge il carattere successivo alla stringa, SB. L'output è:

Un testo 1 a testo 1 a testo 1 a testo 1 a testo 1
B testo 2 b testo 2 b testo 2 b testo 2 b testo 2
C Testo 3 C Testo 3 C Testo 3 C Testo 3 C Testo 3

È esattamente il contenuto del file, ma ha aggiunto una riga extra nel computer dell'autore.

Leggere in un array

Quando si legge in un array, il contenuto dell'array deve essere rilasciato, per leggere la sequenza successiva di caratteri. Il seguente codice illustra questo:

StringBuilder SB = new StringBuilder ();
Tentativo
FileReaderFr = new FileReader ("DIR1/TEMP.TXT");
mentre (fr.pronto())
char [] arr = new char [5];
int offset = 0;
fr.leggi (arr, offset, 5);
offset = offset + 5;
Sistema.fuori.stampa (arr);


catch (eccezione e)
e.getMessage ();

Sistema.fuori.println ();

Il valore dell'offset deve essere incrementato per ogni iterazione per la lunghezza dell'array. L'output è:

Un testo 1 a testo 1 a testo 1 a testo 1 a testo 1
B testo 2 b testo 2 b testo 2 b testo 2 b testo 2
C Testo 3 C Testo 3 C Testo 3 C Testo 3 C Testo 3

È esattamente come il contenuto del file, ma ha aggiunto una riga extra, nel computer dell'autore.

Lettura di file byte

Costruire un oggetto FileInputStream

Il seguente file di immagine si chiama barre.png. È nella directory utente@host: ~/dir1 $, che è la stessa directory di temp.TXT. È costituito da solo tre barre di colore:

Costruire un fileinputstream

Un costruttore per un oggetto FileInputStream è:

Public FileInputStream (Nome stringa) lancia FileNotFoundException

Dal momento che lancia un'eccezione, dovrebbe essere in un costrutto di cattura. Ricorda che questa classe è per la lettura di byte.

Metodi importanti di FileInputStream

Se il costruttore viene creato correttamente, il file viene considerato aperto. Dopo aver letto i byte, il file deve essere chiuso, impiegando la seguente sintassi:

public void Close () lancia ioException

Dopo che il file è stato appena aperto, non si è ancora verificata una lettura efficace del file. Per leggere un byte alla volta (uno poi successivo), impiega la sintassi del metodo FileInputStream:

public int read () lancia ioException

Questo restituisce il byte (come intero) letto o -1 se è stata raggiunta la fine del flusso (flusso di copia del file in memoria).

Ricorda che dopo questa lettura efficace, l'oggetto FileInputStream deve essere chiuso, con il suo metodo vicino.

Per avere una stima del numero di byte rimanenti da leggere, impiega la sintassi del metodo:

public int disponibile () lancia ioException

Poiché questo metodo restituisce una stima, se usato insieme a read (), non si può essere sicuri che tutti i byte del file siano stati letti. E il seguente metodo che legge tutti i byte dovrebbe essere preferito:

byte pubblico [] readallbytes () lancia ioexception

Questo metodo restituisce tutti i byte rimanenti ma leggerebbe comunque l'intero file.

Leggendo in un arraylist

L'ArrayList deve essere importato dal Java.util.* pacchetto. Il seguente codice legge una stima di tutti i byte in un oggetto ArrayList:

ArrayList al = new ArrayList ();
Tentativo
FileInputStream FIR = new FileInputStream ("DIR1/BARS.png ");
mentre (FIR.disponibile ()> 0)
byte bt = (byte) abete.Leggere();
al.Aggiungi (BT);


catch (eccezione e)
e.getMessage ();

Sistema.fuori.println (al);

Il codice inizia con l'istanziazione di un oggetto ArrayList, Al. Quindi, c'è il costrutto di cattura. Il blocco di prova inizia con l'istanziazione di FileInputStream, FIR. E c'è il while-loop, che itera fino a disponibile () e suggerisce che non viene lasciato alcun byte da leggere. La prima affermazione nel while-loop legge e restituisce il byte successivo come intero. Deve essere lanciato su un byte. L'istruzione successiva nell'apprendimento del circuito while (aggiunge) il carattere successivo all'elenco, AL. L'output è:

[-119, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, -7, 0, 0, 0, - 10, 8, 6, 0, 0, 0, 20, 25, 33, 69, 0, 0, 0, 6, 98, 75, 71, 68, 0, -1, 0, -1, 0, -1 , -96, -67, -89, -109, 0, 0, 3, 48, 73, 68, 65, 84, 120, -100, -19, -42, 49, 74, 67, 81, 0, 68, -47, -81, -68, 52, 105, 83, -120, 85, 42, 65, -112, -12, 41, 44, 92, 64, -74, -26, 34, 92, -110, -115, -107, 32, -23, -19, 44, 4, 9, -60, 85, 60, 62, 92, -50, 89, -63, 52, 23, -26, - 26, -70, 44, -41, 5, 104, 58, -99 - - e continua - - -]

I byte sono numeri interi. Speriamo che l'immagine delle tre barre precedenti consiste in tutti questi byte. L'idea è che il programmatore cambi alcuni byte, modifichi l'immagine e quindi salva il risultato; Quindi riformularlo con il Viewer immagine mentre si presenta un'immagine modificata. Tuttavia, questo programma extra non è affrontato in questo articolo.

Leggere in un array

Il metodo ReadAllBytes () restituisce un array di byte. Quindi, ricevi solo i valori di ritorno, con un array di byte, come mostra il seguente codice:

byte [] arr = new byte [1000];
Tentativo
FileInputStream FIR = new FileInputStream ("DIR1/BARS.png ");
arr = abete.readallbytes ();

catch (eccezione e)
e.getMessage ();

per (int i = 0; iSistema.fuori.print (arr [i] + ",");
Sistema.fuori.println ();

Il codice inizia con la dichiarazione dell'array che riceverà i byte. La dimensione (lunghezza) qui dovrebbe essere al di sopra della dimensione stimata. La dimensione stimata può essere ottenuta con il metodo disponibile (). Il codice principale è nel blocco del tentativo. L'output è:

-119, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, -7, 0, 0, 0, -10, 8, 6, 0, 0, 0, 20, 25, 33, 69, 0, 0, 0, 6, 98, 75, 71, 68, 0, -1, 0, -1, 0, -1, - 96, -67, -89, -109, 0, 0, 3, 48, 73, 68, 65, 84, 120, -100, -19, -42, 49, 74, 67, 81, 0, 68, -47, -81, -68, 52, 105, 83, -120, 85, 42, 65, -112, -12, 41, 44, 92, 64, -74, -26, 34, 92, -110 , -115, -107, 32, -23, -19, 44, 4, 9, -60, 85, 60, 62, 92, -50, 89, -63, 52, 23, -26, -26, -70, 44, -41, 5, 104, 58, -99, - - - e continua - - -

Questo output e il precedente sono gli stessi sul computer dell'autore.

Conclusione

I file di testo e byte locali possono essere letti. Per leggere un file di testo, utilizzare la classe di streaming, FileReader. Per leggere un file byte, utilizzare la classe di streaming, fileinputstream. Entrambe le classi sono nel Java.io.* pacchetto, che dovrebbe essere importato. Queste due classi hanno costruttori e metodi che consentono la lettura. Speriamo che tu abbia trovato utile l'articolo. Dai un'occhiata ad altri articoli di suggerimento Linux per ulteriori suggerimenti e tutorial.