Docsity
Docsity

Prepara i tuoi esami
Prepara i tuoi esami

Studia grazie alle numerose risorse presenti su Docsity


Ottieni i punti per scaricare
Ottieni i punti per scaricare

Guadagna punti aiutando altri studenti oppure acquistali con un piano Premium


Guide e consigli
Guide e consigli


Java file txt, Appunti di Programmazione Avanzata

Appunti per la gestione dei file di testo in java

Tipologia: Appunti

2014/2015

Caricato il 24/07/2015

mastodilu
mastodilu 🇮🇹

2 documenti

1 / 5

Toggle sidebar

Questa pagina non è visibile nell’anteprima

Non perderti parti importanti!

bg1
1/5
Input Output File
In Java è possibile gestire i le usandoli ad esempio per memorizzare dei dati, che saranno poi sempre
disponibili nchè il le non verrà cancellato.
La sequenza di istruzioni che consente di fare ciò è all'incirca sempre la medesima:
si importano delle determinate classi per gestire lettura, scrittura ed errori;
si crea un oggetto (stream) che servirà a leggere e scrivere un usso di dati da e sul le;
si usano i blocchi try/catch per la gestione degli errori;
si modica il le come si vuole;
si chiude il le correttamente.
Di base una scrittura su un le vuoto la si esegue così:
import java.io.PrintWriter; // permette di aprire il file
import java.io.FileNotFoundException; // permette di lanciare l'eccezione in caso di errori in apertura
public class InputFileEsempio {
public static void main (String[] args) {
System.out.print("Nome del file:\n> "); // chiedo il nome del file (es. mioFile.txt)
String nomeFile = SavitchIn.readLine();
PrintWriter outputStream = null; // creo la variabile outputStream per aprire il file
try {
outputStream = new PrintWriter( nomeFile ); // provo ad aprire il file,
// in caso di errore lancia l'eccezione
}
catch ( FileNotFoundException e) {
System.out.println("Errore apertura file: " + nomeFile);
System.exit(0);
}
/* alternativamente potevo usare:
try {
PrintWriter outputStream = new PrintWriter(nomeFile);
}
catch(FileNotFoundException e) {
// istruzioni.....
}
ma non sarei più in grado di usare outputStream.istruzione
(ad esempio outputStream.println()) al di fuori del blocco try{}
*/
// scrivo due righe di testo sul file txt
outputStream.println("riga 1");
outputStream.println("riga 2");
outputStream.close(); // svuota il buffer, finisce di scrivere sul file e
// lo chiude correttamente
}
}
Un le in un programma Java ha due nomi: quello vero e proprio (es mioFile.txt) e quello utilizzato dal
programma Java per lavorarci e modicarlo, cioè lo stream (outputStream).
Aprire un le in questo modo lo crea se non esiste, lo sovrascrive con un le vuoto se esiste già, da errore se
non lo apre.
Per aggiungere dati in fondo a un le di testo si usa:
PrintWriter outputStream = new PrintWriter( new FileOutputStream("mioFile.txt",true) );
pf3
pf4
pf5

Anteprima parziale del testo

Scarica Java file txt e più Appunti in PDF di Programmazione Avanzata solo su Docsity!

Input Output File

In Java è possibile gestire i file usandoli ad esempio per memorizzare dei dati, che saranno poi sempre

disponibili finchè il file non verrà cancellato.

La sequenza di istruzioni che consente di fare ciò è all'incirca sempre la medesima:

si importano delle determinate classi per gestire lettura, scrittura ed errori;

si crea un oggetto (stream) che servirà a leggere e scrivere un flusso di dati da e sul file;

si usano i blocchi try/catch per la gestione degli errori;

si modifica il file come si vuole;

si chiude il file correttamente.

Di base una scrittura su un file vuoto la si esegue così:

import java.io.PrintWriter; // permette di aprire il file import java.io.FileNotFoundException; // permette di lanciare l'eccezione in caso di errori in apertura

public class InputFileEsempio {

public static void main (String[] args) { System.out.print("Nome del file:\n> "); // chiedo il nome del file (es. mioFile.txt) String nomeFile = SavitchIn.readLine();

PrintWriter outputStream = null; // creo la variabile outputStream per aprire il file try { outputStream = new PrintWriter( nomeFile ); // provo ad aprire il file, // in caso di errore lancia l'eccezione } catch ( FileNotFoundException e) { System.out.println("Errore apertura file: " + nomeFile); System.exit(0); } /* alternativamente potevo usare: try { PrintWriter outputStream = new PrintWriter(nomeFile); } catch(FileNotFoundException e) { // istruzioni..... } ma non sarei più in grado di usare outputStream.istruzione (ad esempio outputStream.println()) al di fuori del blocco try{} */

// scrivo due righe di testo sul file txt outputStream.println("riga 1"); outputStream.println("riga 2");

outputStream.close(); // svuota il buffer, finisce di scrivere sul file e // lo chiude correttamente } }

Un file in un programma Java ha due nomi: quello vero e proprio (es mioFile.txt) e quello utilizzato dal

programma Java per lavorarci e modificarlo, cioè lo stream (outputStream).

Aprire un file in questo modo lo crea se non esiste, lo sovrascrive con un file vuoto se esiste già, da errore se

non lo apre.

Per aggiungere dati in fondo a un file di testo si usa:

PrintWriter outputStream = new PrintWriter( new FileOutputStream("mioFile.txt",true) );

import java.io.PrintWriter; import java.io.FileNotFoundException;

public class InputFileEsempio { public static void main( String[] args ) { PrintWriter outputStream = null; try { outputStream = new PrintWriter( new FileOutputStream("mioFile.txt",true) ); } catch (FileNotFoundException e) { System.out.println("errore apertura file"); System.exit(0); } outputStream.println("una riga a caso");

outputStream.close(); } }

E' possibile leggere sul file che abbiamo creato (mioFile.txt) con la classe Scanner , ammettendo che il file

esista già.

import java.util.Scanner; import java.io.File; import java.io.FileNotFoundException;

public class OutputFileEsempio { public static void main( String[] args ) { String nomeFile = "mioFile.txt";

Scanner inputStream = null; // creo l'oggetto inputStream di tipo Scanner che conterrà // ciò che leggo System.out.println("Contenuto del file:\n");

try { inputStream = new Scanner( new File(nomeFile) ); // passa come argomento all'oggetto di tipo Scanner un oggetto di tipo File con il // nome scelto, perchè // la classe Scanner non dispone di un costruttore diretto che faccia: // new Scanner(nomeFile); } catch (FileNotFoundException e) { System.out.println("errore apertura file"); System.exit(0); }

while ( inputStream.hasNextLine() ) // legge anche la successiva riga se esiste { String riga = inputStream.nextLine(); // la riga letta è una stringa che viene stampata System.out.println(riga); }

inputStream.close(); } }

alcuni metodi della classe Scanner utili per lo stream da file:

  • nome_oggetto_stream.hasNext();

restituisce true se successivamente c'è almeno una sequenza di caratteri delimitata da uno spazio

(ad es: la successiva parola)

  • nome_oggetto_stream.hasNextLine();

restituisce true se successivamente c'è almeno un'altra riga da leggere (true se non è finito il file)

  • nome_oggetto_stream.hasNextDouble();

restituisce true se successivamente c'è almeno un altro numero di tipo double da leggere

  • nome_oggetto_stream.hasNextInt();

restituisce true se successivamente c'è almeno un altro numero di tipo int da leggere

ad esempio: inputStream.hasNextLine();

per altri metodi vedere la classe Scanner.

In pratica consente di verificare determinate proprietà del file.

import java.util.Scanner; import java.io.File; // per poter usare la classe Scanner import java.io.FileNotFoundException;

class ClasseFile { public static void main(String[] args) { File mioFile = new File("mioFile.txt"); // oggetto identificativo del file if ( !mioFile.exists() ) // se il file non esiste System.out.println("File non esistente."); else if ( !mioFile.canRead() ) // se il file esiste ma non può essere letto System.out.println("File non leggibile"); } }

Ad esemio è possibile ciclare con un while quando l'utente continua a scrivere un nome sbagliato e smettere

di ciclare nel momento in cui il nome inserito corrispone ad un file esistente.

Alcuni metodi della classe File:

  • public boolean canRead()

true quando il programma può leggere il file;

  • public boolean canWrite()

true quando il programma può scrivere sul file;

  • public boolean delete()

true quando il programma ha potuto cancellare il file;

  • public boolean exists()

true quando il programma ha trovato un file esistente con lo stesso nome del costruttore oggetto della

classe File;

  • public String getName()

restituisce il nome (senza l'eventuale percorso) passato al costruttore dell'oggetto file;

  • public String getPath()

restituisce il percorso del file;

  • public long length()

restituisce il numero di byte che compongono il file.

/* esercizio: dato il file numeriInteri.txt, composto da soli numeri interi scritti uno per riga, calcolare e stampare massimo, minimo e media. */ import java.io.FileNotFoundException; import java.io.File; import java.util.Scanner;

class Esercizio { public static void main(String[] args) { File mioFile = new File("numeriInteri.txt"); if (mioFile.exists() && mioFile.canRead()) { try { Scanner stream = new Scanner(mioFile); int numero = Integer.parseInt( stream.nextLine() ); int massimo = numero, minimo = numero, conta = 1; double media = numero; while ( stream.hasNextLine() ) { numero = Integer.parseInt( stream.nextLine() ); conta++; if (numero < minimo) minimo = numero; if (numero > massimo) massimo = numero; media = media + numero; } media = media / conta; System.out.println("massimo - minimo - media"); System.out.println(massimo +"\t"+ minimo +"\t"+ media); } catch (FileNotFoundException e) { System.out.println("errore apertura file."); } } else System.out.println("errore apertura/lettura file."); } }