😄
Junkai’s Blogs
AboutDonate

IO

Tags
Published
Author

La gestione degli Input/Output in Java

In Java, la gestione degli input/output (I/O) è una parte essenziale della programmazione, in quanto permette di leggere e scrivere dati da e verso varie fonti come file, terminali, e altre risorse di sistema.
Il pacchetto java.io fornisce una vasta gamma di classi e interfacce che consentono di lavorare con i flussi di dati (streams).

Cos'è l'I/O in Java?

L'I/O in Java si riferisce a tutte le operazioni che permettono di interagire con il sistema operativo e altre risorse esterne per leggere o scrivere dati. Le principali categorie di I/O sono:
  • Input: la lettura di dati da una sorgente, come tastiera, file o rete.
  • Output: la scrittura di dati verso una destinazione, come schermo, file o rete.
Java fornisce due principali tipi di flussi (streams) per la gestione di I/O:
  • Flussi di byte (byte streams): gestiscono i dati come sequenze di byte. Sono adatti per operazioni generiche di lettura e scrittura di file binari.
  • Flussi di caratteri (character streams): gestiscono i dati come sequenze di caratteri. Sono particolarmente utili per lavorare con file di testo e garantire che i dati vengano letti e scritti correttamente rispetto alla codifica dei caratteri.

Flussi di byte (Byte Streams)

I flussi di byte sono utilizzati per la lettura e la scrittura di dati binari. Le classi principali per lavorare con i flussi di byte sono InputStream e OutputStream, dalle quali derivano varie implementazioni.

Lettura di un file con FileInputStream

Per leggere i dati da un file binario, viene utilizzata la classe FileInputStream, che permette di aprire e leggere i byte dal file.
Un esempio di come leggere i dati da un file utilizzando FileInputStream:
import java.io.FileInputStream;
import java.io.IOException;

public class LetturaFileByte {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("esempio.txt")) {
            int dato;
            while ((dato = fis.read()) != -1) {
                System.out.print((char) dato);
            }
        } catch (IOException e) {
            System.err.println("Errore durante la lettura del file: " + e.getMessage());
        }
    }
}
In questo esempio, viene utilizzato un FileInputStream per leggere il contenuto di un file chiamato "esempio.txt" byte per byte. L'operazione continua finché non si raggiunge la fine del file (-1).

Scrittura di un file con FileOutputStream

Per scrivere dati in un file binario, si utilizza la classe FileOutputStream. Ecco come scrivere una sequenza di byte in un file:
import java.io.FileOutputStream;
import java.io.IOException;

public class ScritturaFileByte {
    public static void main(String[] args) {
        String contenuto = "Questo è un esempio di scrittura su file.";

        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            byte[] dati = contenuto.getBytes();
            fos.write(dati);
        } catch (IOException e) {
            System.err.println("Errore durante la scrittura del file: " + e.getMessage());
        }
    }
}
In questo caso, un'istanza di FileOutputStream viene utilizzata per scrivere i byte di una stringa nel file "output.txt".

Flussi di caratteri (Character Streams)

I flussi di caratteri sono utilizzati per leggere e scrivere dati in formato testo. Le classi principali per la gestione dei flussi di caratteri sono Reader e Writer, dalle quali derivano varie implementazioni.

Lettura di un file con FileReader

Per leggere un file di testo, viene utilizzata la classe FileReader, che legge i dati come caratteri.
Ecco un esempio di come leggere il contenuto di un file di testo utilizzando FileReader:
import java.io.FileReader;
import java.io.IOException;

public class LetturaFileCaratteri {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("esempio.txt")) {
            int carattere;
            while ((carattere = fr.read()) != -1) {
                System.out.print((char) carattere);
            }
        } catch (IOException e) {
            System.err.println("Errore durante la lettura del file: " + e.getMessage());
        }
    }
}
In questo esempio, un FileReader viene utilizzato per leggere i caratteri da "esempio.txt". I caratteri letti vengono stampati sulla console.

Scrittura di un file con FileWriter

Per scrivere un file di testo, si utilizza la classe FileWriter. Ecco un esempio di come scrivere una stringa in un file di testo:
import java.io.FileWriter;
import java.io.IOException;

public class ScritturaFileCaratteri {
    public static void main(String[] args) {
        String contenuto = "Questo è un esempio di scrittura su file di testo.";

        try (FileWriter fw = new FileWriter("output.txt")) {
            fw.write(contenuto);
        } catch (IOException e) {
            System.err.println("Errore durante la scrittura del file: " + e.getMessage());
        }
    }
}
In questo esempio, un'istanza di FileWriter viene utilizzata per scrivere il contenuto di una stringa nel file "output.txt".

Buffered Streams

Per ottimizzare le operazioni di lettura e scrittura, specialmente quando si lavora con file di grandi dimensioni, Java fornisce le classi BufferedReader e BufferedWriter. Queste classi "bufferizzano" i dati in memoria, riducendo il numero di operazioni di lettura e scrittura effettive sul file.

Esempio di utilizzo di BufferedReader

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LetturaFileBuffered {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("esempio.txt"))) {
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (IOException e) {
            System.err.println("Errore durante la lettura del file: " + e.getMessage());
        }
    }
}
In questo esempio, un BufferedReader viene utilizzato per leggere il contenuto di un file riga per riga, ottimizzando le prestazioni.

Gestione delle eccezioni

La gestione delle eccezioni è fondamentale durante le operazioni di I/O. Gli errori comuni includono la mancata esistenza di un file, errori di accesso ai file o la mancanza di permessi per leggere o scrivere in un file. Le operazioni di I/O solitamente generano eccezioni di tipo IOException, che devono essere gestite adeguatamente, come mostrato negli esempi precedenti.

Back to →
🐚
Java