LA GESTIONE DEI FILE IN JAVA
Per lavorare con i file Java mette a disposizione diverse classi che consentono di:
- creare file e directory
- cercare file e directory
- rinominare file e directory
- cancellare file e directory
- scrivere all’interno di un file
- leggere il testo contenuto in un file
Le classi principali si trovano nel package java.io (io sta per InputOutput …) e sono:
- per la gestione:
- java.io.File
- per la scrittura:
- java.io.FileWriter
- java.io.BufferedWriter
- java.io.PrintWriter
- per la lettura:
- java.io.FileReader
- java.io.BufferedReader
- File: è una rappresentazione di un file o di una directory. Questa classe permette di creare, eliminare, rinominare e cercare un file, una directory (o sottodirectory)
- FileWriter: consente di scrivere in un file di testo un carattere per volta
- BufferedWriter: è simile alla classe FileWriter ma consente di scrivere i caratteri nel file in blocchi, memorizzati in un buffer temporaneo. I caratteri vengono letti dal buffer e scritti sul file. Questa classe ha delle performance migliori della classe FileWriter
- PrintWriter: è simile alla classe BufferedWriter ma consente di scrivere nel file testo formattato
- FileReader: consente di leggere i caratteri contenuti in un file di testo, leggendoli uno per volta
- BufferedReader: è simile alla classe FileReader ma consente di leggere i caratteri presenti nel file in blocchi, memorizzati in un buffer temporaneo. Quando i caratteri vengono richiesti, vengono letti dal buffer. Questa classe ha delle performance migliori della classe FileReader
LA CLASSE FILE
ll costruttore principale della classe File riceve in ingresso una variabile di tipo String che contiene il Path del file (cioè il percorso dove salvarlo ed il nome del file o della directory).
Esempi di Path:
- “C:/corsi/java/lezioneX/”
- “C:/corsi/java/lezioneX/file1.txt”
La creazione dell’istanza della classe File non genera la creazione fisica del file o della directory sul disco fisso.
- Per creare file fisicamente è necessario chiamare il metodo createNewFile()
- Per creare directory fisicamente è necessario chiamare il metodo mkdir()
I metodi principali della classe File sono:
- exists(): restituisce true se il file o la directory esiste, false altrimenti
- createNewFile(): crea un file sul disco nel Path specificato
- delete(): elimina il file o la directory dal disco
- isFile(): restituisce true se la risorsa è un file, false altrimenti
- isDir(): restituisce true se la risorsa è una directory, false altrimenti
- mkDir(): crea una directory sul disco nel Path specificato
package it.corso.java.gestionefile;
import java.io.File;
import java.io.IOException;
public class TestFileClass {
public static void create()throws IOException{
//CREO IL PATH PER LA LA DIRECTORY
File f1 = new File(new File(".").getCanonicalPath() + File.separator + "test-dir");
String dir = f1.getPath();
//PATH DEL FILE
String file = dir + File.separator + "test-file.txt";
//CREO LA DIRECTORY
creaDirectory(dir);
//CREO IL FILE
creaFile(file);
//CREO I FILE PER LA LETTURA/SCRITTURA
String file1 = dir + File.separator + "buffered-writer.txt";
creaFile(file1);
String file2_1 = dir + File.separator + "file-writer.txt";
creaFile(file2_1);
String file3 = dir + File.separator + "lettura.txt";
creaFile(file3);
File d = new File(dir);
System.out.println(d.isDirectory());
File f = new File(file);
System.out.println(f.isFile());
File[] files = d.listFiles();
for (File file2 : files) {
System.out.println(file2.getName());
}
}
public static void creaFile(String path) {
File f = new File(path);
if(!f.exists()) {
try {
f.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void creaDirectory(String path) {
File d = new File(path);
if(!d.exists()) {
d.mkdir();
}
}
}
LA CLASSE FILEWRITER
Quando creiamo un’istanza della classe FileWriter, al costruttore è necessario passare in ingresso un’istanza della classe File.
I metodi principali della classe FileWriter sono:
- write(String str): scrive la stringa str nel file
- close(): chiude lo stream sul file
- flush(): garantisce che tutto il testo sia stato scritto nel file
LA CLASSE BUFFEREDWRITER
La classe FileWriter, come abbiamo detto, scrive un singolo carattere per volta. La classe BufferedWriter consente di scrivere su file in maniera più efficiente rispetto alla classe FileWriter. Quando creiamo un’istanza della classe BufferedWriter, al costruttore è necessario passare in ingresso un’istanza della classe FileWriter.
I metodi principali della classe BufferedWriter sono:
- write(String str): scrive la stringa str nel file
- newLine(): crea una nuova linea nel file. Il testo che segue questa istruzione viene scritto su una nuova linea.
- close(): chiude lo stream sul file
- flush(): garantisce che tutto il testo sia stato scritto nel file
package it.corso.java.gestionefile;
import java.io.*;
public class WriteClassFile {
public static void write() {
try {
String dir = new File(new File(".").getCanonicalPath() + File.separator + "test-dir").getPath();
esempioBufferedFileWriter(dir + File.separator + "buffered-writer.txt", new String[]{"Marco", "Albasini", "Corso Java", "Avanzato!"});
esempioFileWriter(dir + File.separator + "file-writer.txt", new String("Corso Java avanzato"));
}
catch(IOException e) {
e.printStackTrace();
}
}
public static void esempioPrintWriter(String filePath, String[] testo) {
PrintWriter pw = null;
try {
pw = new PrintWriter(new FileWriter(getFile(filePath)));
for (String string : testo) {
pw.write(string);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
pw.close();
}
}
public static void esempioBufferedFileWriter(String filePath, String[] testo) {
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new FileWriter(getFile(filePath)));
for (String string : testo) {
bw.write(string);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void esempioFileWriter(String filePath, String testo) {
FileWriter fw = null;
try {
fw = new FileWriter(getFile(filePath));
fw.write(testo);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static File getFile(String filePath) {
File file = new File(filePath);
if(!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
return file;
}
}
LA CLASSE FILEREADER
Quando creiamo un’istanza della classe FileReader, al costruttore è necessario passare in ingresso un’istanza della classe File. I metodi principali della classe FileReader sono:
- read(char[]): legge un numero finito di caratteri, uno alla volta, e li memorizza nell’array di char passato in ingresso
- close(): chiude lo stream dal file.
LA CLASSE BUFFEREDREADER
La classe BufferedReader consente di leggere da un file in maniera più efficiente rispetto alla classe FileReader che legge un singolo carattere per volta. Quando creiamo un’istanza della classe BufferedReader, al costruttore è necessario passare in ingresso un’istanza della classe FileReader. I metodi principali della classe BufferedReader sono:
- read(char[]): legge un numero finito di caratteri, uno alla volta, e li memorizza nell’array di char passato in ingresso
- close(): chiude lo stream dal file
package it.corso.java.gestionefile;
import java.io.*;
public class ReadClassFile {
public static void read(){
try {
String dir = new File(new File(".").getCanonicalPath() + File.separator + "test-dir").getPath();
esempioFileReader(dir + File.separator + "lettura.txt");
esempioBufferedReader(dir + File.separator + "lettura.txt");
}
catch(IOException ex){
ex.printStackTrace();
}
}
public static void esempioBufferedReader(String filePath) {
File f = new File(filePath);
if(f.exists()) {
BufferedReader fr = null;
try {
fr = new BufferedReader(new FileReader(f));
char[] testo = new char[1024];
int size = fr.read(testo);
for(int i = 0; i < size; i++) {
System.out.print(testo[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void esempioFileReader(String filePath) {
File f = new File(filePath);
if(f.exists()) {
FileReader fr = null;
try {
fr = new FileReader(f);
char[] testo = new char[1024];
int size = fr.read(testo);
for(int i = 0; i < size; i++) {
System.out.print(testo[i]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
LINK AI POST PRECEDENTI
LINK AL CODICE SU GITHUB
ESECUZIONE DEL CODICE DI ESEMPIO
- Scaricare il codice da GITHUB, lanciare il file JAR con il seguente comando in Visual Studio Code, posizionandosi nella directory contenente il JAR.
java -jar –enable-preview CorsoJava.jar
- Oppure mettere in esecuzione il main che si trova nel file CorsoJava.java.
Scrivi un commento