Fluxuri de citire și scriere la nivel de caractere

Ce sunt fluxurile în general în limbajul Java, dar și fluxurile la nivel de caractere am explorat în postarea 👉 Fluxuri în Java
Vom analiza mai jos clasele Java care permit operarea cu  fluxurile de caractere

• FileReader
• FileWriter
• BufferedReader
• BufferedWriter

Acestea permit programelor să citească și să scrie text în fișiere într-un mod simplu.

Clasa FileReader este utilizată pentru citirea caracterelor dintr-un fișier text. Pentru a putea folosi această clasă, trebuie mai întâi să creăm un obiect FileReader, iar acest lucru se face prin constructori.

Clasa FileReader are doi constructori principali: 

• FileReader(String cale)- primește ca parametru calea către fișier, sub formă de text, String. Programul deschide fișierul respectiv pentru citire.
• FileReader(File fisier)- primește ca parametru un obiect de tip File care reprezintă fișierul ce trebuie citit. Mai întâi se creează obiectul File, iar apoi acesta este transmis constructorului FileReader.

Exemplu comparativ: 

// varianta 1

FileReader fr1 = new FileReader("text.txt");

// varianta 2

File f = new File("text.txt");

FileReader fr2 = new FileReader(f);

Ambele variante deschid același fișier pentru citire. 

Metode importante ale clasei FileReader: 

• read() - citește un caracter din fișier
• close() - închide fișierul, fluxul de intrare deschis

Exemplu 1. Citirea datelor din fișier cu metoda read() a clasei FileReader.

import java.io.*;
public class Main{
 public static void main(String[] args) throws IOException {
   FileReader fr = new FileReader("D:\\documente\\TestFile1.txt");
   int c;
   while ((c = fr.read()) != -1) {
    System.out.print((char)c);
   }
  fr.close();
 }}

Variabila c, de tip întreg (int), stochează codul numeric al caracterului citit din fișier. 

Metoda read() returnează un număr întreg care este codul caracterului citit din fișier, iar la sfârșitul fișierului returnează valoarea -1, ceea ce înseamnă că nu mai este nimic de citit.

Exemplu 2. Citirea datelor din fișier cu metodele clasei Scanner.

import java.io.*;
import java.util.Scanner;
public class Main{
 public static void main(String[] args) throws IOException {
     FileReader fr = new FileReader("D:\\documente\\TestFile1.txt");
     Scanner sc = new Scanner(fr);
     while (sc.hasNextLine()) {
         String linie = sc.nextLine();
         System.out.println(linie);
     }
     sc.close();
     fr.close();
 }}

Pentru ca programul să citească și să afișeze numere din fișier, este mai potrivit să folosim clasa Scanner, deoarece aceasta poate identifica direct valori numerice (int, double etc.). FileReader va deschide fișierul, iar Scanner va citi numerele din el.

Exemplu 3. Citirea datelor de tip primitiv din fișier cu metodele clasei Scanner.

import java.io.*;
import java.util.*;
public class Main{
 public static void main(String[] args) throws IOException {
     FileReader fr = new FileReader("D:\\documente\\TestFile1.txt");
     Scanner sc = new Scanner(fr);
     System.out.println("Fisierul contine valorile");
     while (sc.hasNextInt()) {
         int numar = sc.nextInt();
         System.out.print(numar + " ");
     }
     sc.close();
     fr.close();
 }}

Clasa Scanner este foarte practică atunci când dorim să citim numere, cuvinte sau linii întregi din fișiere, deoarece identifică automat tipul datelor.😍

Clasa BufferedReader este utilizată pentru citirea eficientă a textului din fișiere. Aceasta folosește un buffer (memorie temporară) pentru a accelera citirea. Cel mai mare avantaj este metoda readLine(), care citește o linie întreagă. Constructorii clasei sunt: 

• BufferedReader(Reader in) - creează un obiect BufferedReader care citește date dintr-un flux de caractere (Reader). În practică, cel mai des se folosește împreună cu FileReader pentru citirea unui fișier text. Cel mai utilizat constructor.

Exemplu: BufferedReader br = new BufferedReader(new FileReader("text.txt"));

• BufferedReader(Reader in, int dimBuffer)- acest constructor permite specificarea dimensiunii bufferului (memoria temporară utilizată pentru citire) la instanțiere. Reader in este fluxul de caractere din care se citește, iar dimBuffer este dimensiunea bufferului (numărul de caractere).

Exemplu: BufferedReader br = new BufferedReader(new FileReader("text.txt"), 1024);

Exemplu 4. Citirea datelor din fișier folosind clasa FileReader și BufferedReader.

import java.io.*;
public class Main{
 public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader("D:\\documente\\TestFile1.txt"));
    String linie;
    while ((linie = br.readLine()) != null) {
      System.out.println(linie);
      }
    br.close();
 }}

Metoda br.readLine() returnează un String, linia curentă din fișier. Pentru a obține un număr trebuie să folosim metode de conversie:

• Integer.parseInt() - convertește stringul citit în int
• Double.parseDouble() - convertește stringul citit în double
• Float.parseFloat() - convertește stringul citit în float

Exemplu 5. Citirea datelor din fișier folosind clasa FileReader și BufferedReader în cazul în care pe fiecare linie se află o valoare.

import java.io.*;
public class Main{
 public static void main(String[] args) throws IOException {
     BufferedReader br = new BufferedReader(new FileReader("D:\\documente\\TestFile1.txt"));
     String linie;
     while ((linie = br.readLine()) != null) {
         int numar = Integer.parseInt(linie); 
         System.out.println(numar);
     } br.close();
 }}

Exemplu 6. Citirea datelor din fișier folosind clasa FileReader și BufferedReader în cazul în care pe fiecare linie se află mai multe valori.

import java.io.*;
public class Main{
 public static void main(String[] args) throws IOException {
   BufferedReader br = new BufferedReader(new FileReader("D:\\documente\\TestFile1.txt"));
   String linie;
   while ((linie = br.readLine()) != null) {
    String[] numere = linie.split(" ");
     for (String n : numere) {
       int numar = Integer.parseInt(n);
       System.out.println(numar);
     }}
     br.close();
 }}

BufferedReader nu citește direct numere, ci text. De aceea citirea numerelor din fișiere, în practică este mai simplu să folosim Scanner, deoarece el poate citi direct numere (nextInt(), nextDouble()), fără conversii.

Exemplu 7. Citirea datelor din fișier folosind clasa FileReader și Scanner în cazul în care pe fiecare linie se află mai multe valori de diferite tipuri. Cum ar fi int, String și String:

import java.io.*;
import java.util.*;
public class Main{
 public static void main(String[] args) throws IOException {
     Scanner sc = new Scanner(new FileReader("D:\\documente\\TestFile1.txt"));
     while (sc.hasNext()) {
         int id = sc.nextInt();
         String nume = sc.next();
         String prenume = sc.next();
         System.out.println("ID: " + id +
                 " Nume: " + nume +
                 " Prenume: " + prenume);
     } sc.close();
 }}

Exemplu 8. Citirea datelor din fișier folosind clasa FileReader și BufferedReader în cazul în care pe fiecare linie se află mai multe valori de diferite tipuri. Cum ar fi int, String și String:

import java.io.*;
public class Main{
 public static void main(String[] args) throws IOException {
     BufferedReader br = new BufferedReader(new FileReader("D:\\documente\\TestFile1.txt"));
     String linie;
     while ((linie = br.readLine()) != null) {
      String[] date = linie.split("\\s+");
      int id = Integer.parseInt(date[0]);
      String nume = date[1];
      String prenume = date[2];
      System.out.println("ID: " + id +" Nume: " + nume + " Prenume: " + prenume);
     }
     br.close();
 }}

În ambele programe se citește date dintr-un fișier și se afișează câte un int urmat de două String (ID, Nume, Prenume).

Varianta cu Scanner citește fișierul element cu element (nextInt(), next()), fiind simplă și directă pentru date bine structurate.

Varianta cu BufferedReader citește fișierul linie cu linie, apoi separă elementele cu split(), oferind mai mult control asupra procesării liniei și este mai eficientă pentru fișiere mari.

Practic, ambele obțin același rezultat, dar dacă ai un fișier mic și vrei cod rapid și clar, Scanner e ok, pentru fișiere mari sau procesări mai complexe, BufferedReader e mai performant.

Pentru a scrie sau transmite date (caractere) în fișiere text este clasa FileWriter care are mai mulți constructori principali, care permit să creezi un obiect FileWriter în funcție de ce informații ai despre modul în care trebuie să ajungă datele în fișier: 

• FileWriter(String fileName) - creează un fișier sau îl deschide dacă există. Dacă fișierul există, suprascrie conținutul.
• FileWriter(String fileName, boolean append) - la fel ca primul constructor, doar că al doilea parametru true înseamnă că se adaugă la sfârșitul fișierului (append). Astfel  că, la conținutul deja existent în fișier se adaugă noua informație. Valoarea false sau lipsa celui de al doilea parametrul va suprascrie fișierul.
• FileWriter(File file) - Primește un obiect File în loc de șir. Comportament similar primului constructor, suprascrie fișierul dacă există.
• FileWriter(File file, boolean append) -  Primește un obiect File în loc de șir. Pentru valoara true în cel de al doilea parametru va efectua anexarea datelor în fișier păstrând conținutul anterior.

Exemplu 9. Scrierea unei propoziții în fișier folosind clasa FileWriter:

import java.io.*;
public class Main{
         public static void main(String[] args) throws IOException {
             String propozitie = "Aceasta este o propoziție scrisă în fișier.";
             FileWriter fw = new FileWriter("D:\\documente\\Propozitie.txt");
             fw.write(propozitie);
             fw.close();  
             System.out.println("Propoziția a fost scrisă cu succes!");
 }}

 

Exemplu 10. Scrierea în fișier folosind clasa FileWriter a datelor introduse de utilizator de la tastatură:

import java.io.*;
import java.util.*;
public class Main{
  public static void main(String[] args) throws IOException {
    Scanner in = new Scanner(System.in);
    System.out.println ("Ce ID? ");
    int id = in.nextInt();
    System.out.println ("Ce nume? ");
    String nume = in.next();
    System.out.println ("Ce prenume? ");
    String prenume = in.next();
    FileWriter fw = new FileWriter("D:\\documente\\Date.txt");
     fw.write(id + " " + nume + " " + prenume + "\n");
    System.out.println("Datele au fost scrise cu succes în fișier!");
    fw.close(); in.close();
  }}

  

Vă mai amintiți de instrucțiunea try cu resurse? Să modificăm exemplul anterior: 

Exemplu 11. Scrierea în fișier folosind clasa FileWriter a datelor introduse de utilizator de la tastatură folosind instrucțiuea try cu resurse pentru tratarea excepțiilor:

import java.io.*;
import java.util.*;
public class Main{
  public static void main(String[] args){
   try (Scanner in = new Scanner(System.in);
        FileWriter fw = new FileWriter("D:\\documente\\Date.txt")) {
          System.out.print("Ce ID? ");
          int id = in.nextInt();
          System.out.print("Ce nume? ");
          String nume = in.next();
          System.out.print("Ce prenume? ");
          String prenume = in.next();
          fw.write(id + " " + nume + " " + prenume + "\n");
          System.out.println("Datele au fost scrise cu succes în fișier!");
      } catch (IOException e) {
          System.out.println("Eroare la scrierea fișierului: " + e.getMessage());
  }}}

Avantajele instrucțiunii try cu resurse este că resursele sunt tot închise automat, nu mai trebuie să apelăm metoda close().

Clasa BufferedWriter este o clasă folosită pentru a scrie caractere în fișiere.

Diferența față de FileWriter este că folosește un buffer intern, adică stochează temporar datele în memorie și le scrie dintr-un bloc în fișier.

Oferă o performanță mai bună decât scrierea caracter cu caracter și poate scrie linii întregi cu metoda newLine().

Constructori: 

• BufferedWriter(Writer out) - creează un BufferedWriter care scrie în fișierul specificat prin Writer. Folosește dimensiunea implicită a bufferului (~8192 caractere).

Exemplu: FileWriter fw = new FileWriter("D:\\documente\\Date.txt");

BufferedWriter bw = new BufferedWriter(fw);

• BufferedWriter(Writer out, int sz) - creează un BufferedWriter cu un buffer personalizat de sz caractere. Poate fi util pentru fișiere foarte mari sau scrieri frecvente.  

Exemplu: FileWriter fw = new FileWriter("D:\\documente\\Date.txt");

BufferedWriter bw = new BufferedWriter(fw, 4096);

Exemplu 12. Scrierea în fișier folosind clasa BufferWriter a datelor introduse de utilizator de la tastatură:

import java.io.*;
import java.util.*;
public class Main{
  public static void main(String[] args) throws IOException{
      Scanner in = new Scanner(System.in);
      System.out.print("Ce ID? ");
      int id = in.nextInt();
      System.out.print("Ce nume? ");
      String nume = in.next();
      System.out.print("Ce prenume? ");
      String prenume = in.next();
      BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\documente\\Date.txt"));
      bw.write(id + " " + nume + " " + prenume);
      bw.newLine();  // adaugă linie nouă
      System.out.println("Datele au fost scrise cu succes în fișier!");
      bw.close();
      in.close();
  }}

  

Cam asta e pe scurt despre citirea/ scrierea la nivel de caractere din/în documente text. Data viitoare vorbim despre fluxuri de octeți 👌

Succes!

❤️