Show page

Differences

This shows you the differences between two versions of the page.

--- poo-ca-cd:laboratoare:io-si-gestionarea-exceptiilor [2025/11/17 02:19]
florian_luis.micu [Stream Wrappers]
+++ poo-ca-cd:laboratoare:io-si-gestionarea-exceptiilor [2025/11/19 14:12] (current)
florian_luis.micu
@@ Line 3: / Line 3: @@
   * Autori: [[stefancocioran@gmail.com | Ștefan Cocioran ]], [[miculuis1@gmail.com | Florian-Luis Micu ]], [[sorinabuf@gmail.com | Sorina-Anamaria Buf ]]
   * Data publicării: 17.11.2025
-  * Data ultimei modificări: 17.11.2025
+  * Data ultimei modificări: 19.11.2025
+    * adăugarea unei secțiuni sumare despre I/O în materia fundamentală
+    * mutarea conceptelor avansate despre I/O în secțiuni [Nice to know]
@@ Line 516: / Line 518: @@
 Ele constituie fundamentul pentru toate comunicațiile cu **fișiere, resurse media și rețea**.
-====I/O Streams====
+====The Basics====
+În Java, lucrăm cu două mari tipuri de fluxuri:
+  * **Fluxuri de octeți** (byte streams) – pentru date binare → ''FileInputStream'' / ''FileOutputStream''
+  * **Fluxuri de caractere** (character streams) – pentru text → ''FileReader'' / ''FileWriter'', ''InputStreamReader'' / ''OutputStreamWriter''
+Peste acestea, putem adăuga **buffering** și **funcționalități suplimentare** (Scanner, BufferedReader, PrintWriter etc.).
+===Modalități de citire===
+==Scanner==
+Folosit pentru **fișiere text simple**, când avem nevoie să citim **token-uri**: cuvinte, numere, simboluri.
+Are metode integrate pentru **parsing** (''nextInt()'', ''nextDouble()'' etc.), ceea ce îl face ideal pentru input-uri structurate.
+Este însă **mai lent pentru fișiere mari**, deoarece face parsing și tokenizare internă.
+Poate fi folosit pentru:
+  * citire de la tastatură (ex. ''System.in'')
+  * citire din fișier (ex. ''new File("exemplu.txt")'')
+<code java>
+// Citire din fișier
+try (Scanner sc = new Scanner(new File("exemplu.txt"))) {
+    while (sc.hasNext()) {
+        System.out.println(sc.next());
+    }
+}
+</code>
+<code java>
+// Citire de la tastatură cu conversie automată
+Scanner sc = new Scanner(System.in)
+double d = sc.nextDouble();
+</code>
+<note warning>
+**Nu este recomandat** să închidem Scanner-ul asociat cu ''System.in'', deoarece închide fluxul ''System.in'' și nu mai poate fi reutilizat.
+</note>
+==FileReader==
+Folosit pentru citirea **fișierelor text simple**, când avem nevoie să lucrăm direct cu **caractere**.
+Este un **Reader** de nivel jos, care extrage caractere dintr-un fișier folosind setul de caractere implicit al sistemului (ce poate varia între OS-uri). **Nu oferă funcționalități avansate** precum citirea linie cu linie sau parsarea datelor, fiind practic doar o „ușă” către fișier.
+Este util când vrem să citim text într-un mod **predictibil** și **liniar**, fără procesări suplimentare.
+Poate fi folosit pentru:
+  * citire caracter cu caracter
+  * sursă pentru clase mai performante, precum BufferedReader
+  * citire simplă de fișiere în care nu ne interesează structura datelor
+<code java>
+try (FileReader fr = new FileReader("exemplu.txt")) {
+    int c;
+    while ((c = fr.read()) != -1) {
+        // read() -> întoarce un caracter ca int sau -1 dacă am ajuns la final
+        System.out.print((char) c);
+    }
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+==InputStreamReader==
+Reprezintă un **adaptor** între **fluxuri de octeți** (InputStream) și **fluxuri de caractere** (Reader). Este necesar în situațiile în care primim date brute sub formă de **bytes** (dintr-un socket, fișier binar sau System.in) și vrem să le convertim în caractere cu un anumit **charset**.
+Permite specificarea explicită a encodării (ex. UTF-8), ceea ce îl face esențial în **programe internaționale**, pentru a evita problemele de afișare.
+Poate fi folosit pentru:
+  * citirea textului de la tastatură în mod corect (cu charset setat)
+  * citirea de pe rețea (ex. socket TCP care trimite bytes)
+  * sursă pentru un ''BufferedReader'' atunci când ''FileReader'' nu este potrivit (ex. fișiere cu encoding special)
+<code java>
+// Citim text dintr-un InputStream, dar cu encoding UTF-8 specificat
+try (InputStreamReader isr = new InputStreamReader(
+        new FileInputStream("exemplu_utf8.txt"), StandardCharsets.UTF_8)) {
+    int c;
+    while ((c = isr.read()) != -1) {
+        System.out.print((char) c);
+    }
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+<note tip>
+Rețineți că această clasă este utilă doar dacă vrem să facem conversia de la **conținut binar** la **conținut text**.
+</note>
+==BufferedReader==
+Folosit pentru citirea **eficientă a textului**, deoarece încarcă în memorie blocuri mari de date, reducând numărul de apeluri la sistemul de fișiere. Oferă metoda ''readLine()'', una dintre cele mai utile metode pentru **prelucrarea fișierelor text pe linii**.
+Este ideal pentru **fișiere mari** sau situații în care **performanța contează**, cum ar fi procesarea de log-uri sau citirea continuă dintr-un stream.
+Poate fi folosit pentru:
+  * parcurgerea eficientă, linie cu linie, a unui fișier mare
+  * citirea de la tastatură cu latență minimă
+  * citire prin compunere (ex. ''new BufferedReader(new FileReader(...))'')
+  * situații în care vrem să evităm procesarea caracter-cu-caracter
+<code java>
+try (BufferedReader br = new BufferedReader(new FileReader("exemplu.txt"))) {
+    String line;
+    while ((line = br.readLine()) != null) {
+        // readLine() -> citește o linie întreagă, fără \n
+        System.out.println("Linie citită: " + line);
+    }
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+<note tip>
+Pentru procesarea fișierelor binare eficient puteți folosi ''BufferedInputStream'' și ''FileInputStream''.
+</note>
+===Modalități de scriere===
+==PrintWriter==
+Folosit pentru scrierea de **text** într-un **mod ușor și prietenos**, cu metode precum ''print()'', ''println()'' și ''printf()''. Este ideal când vrem **claritate** și **simplitate** în generarea de text.
+Are opțiunea de **auto-flush**, utilă în aplicații interactive (ex. comunicare prin socket). Este însă **mai lent** decât ''BufferedWriter'' atunci când generăm output masiv, datorită funcțiilor suplimentare de formatare.
+Poate fi folosit pentru:
+  * generare de rapoarte text cu formatare
+  * scriere în console, socket-uri sau fișiere
+  * logging uman-citibil
+  * combinații precum ''new PrintWriter(new BufferedWriter(new FileWriter(...)))''
+<code java>
+try (PrintWriter pw = new PrintWriter(new FileWriter("raport.txt"))) {
+    pw.println("Raport generat automat:");
+    pw.printf("Valoare X: %d, Valoare Y: %.2f\n", 10, 12.345);
+    pw.println("Linie finală.");
+    // Auto-flush dacă folosim constructorul: new PrintWriter(..., true)
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+==FileWriter==
+Folosit pentru a scrie **text simplu** într-un fișier, **caracter cu caracter**. Este echivalentul lui ''FileReader'', dar pentru output. Folosește implicit encoding-ul sistemului, motiv pentru care poate cauza **incompatibilități** dacă fișierul va fi folosit pe alte platforme.
+Nu oferă bufere interne și este **mai lent** pentru volume mari, dar este o soluție minimă, directă și simplă pentru scrierea textului.
+Poate fi folosit pentru:
+  * scriere de fișiere mici
+  * jurnalizare simplă
+  * sursă pentru clase mai performante (ex. BufferedWriter)
+<code java>
+try (FileWriter fw = new FileWriter("output.txt")) {
+    fw.write("Salut!\n");        // scrie caractere direct
+    fw.write("Scriem text simplu.");
+    // write(char[]), write(String), write(int) sunt disponibile
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+==OutputStreamWriter==
+Este perechea lui ''InputStreamReader'', **convertind** **caracterele** Java în **octeți** folosind un anumit **charset**. Este util atunci când vrem să controlăm encoding-ul sau când sursa finală a datelor este un ''OutputStream'' (socket, fișier binar etc.).
+Este clasa de bază pentru output text cu **encoding explicit**, fiind preferabilă în aplicații care trebuie să scrie UTF-8 (majoritatea).
+Poate fi folosit pentru:
+  * scriere în fișiere cu encoding custom
+  * scriere în socket-uri sau procese externe
+  * compunere cu ''BufferedWriter'' sau ''PrintWriter'' pentru performanță și funcționalitate
+<code java>
+try (OutputStreamWriter osw =
+        new OutputStreamWriter(new FileOutputStream("output_utf8.txt"), "UTF-8")) {
+    osw.write("Scriu UTF-8 cu diacritice: ăîșț!");
+    osw.flush(); // forțăm scrierea datelor
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+<note tip>
+Rețineți că această clasă este utilă doar dacă vrem să facem conversia de la **conținut text** la **conținut binar**.
+</note>
+==BufferedWriter==
+Folosit pentru a scrie **text eficient**, deoarece stochează temporar caractere în buffer și le scrie în bloc, reducând accesările la disc. Oferă și metoda ''newLine()'', care inserează un separator de linie independent de OS.
+Este alegerea potrivită pentru **generarea de fișiere mari** sau pentru scriere intensivă în loop-uri mari.
+Poate fi folosit pentru:
+  * scriere rapidă în fișiere
+  * generarea de loguri sau rapoarte
+  * scriere formatată pe linii mari
+  * împreună cu FileWriter sau ''OutputStreamWriter''
+<code java>
+try (BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"))) {
+    bw.write("Prima linie");
+    bw.newLine();                 // adaugă separatorul de linie corect
+    bw.write("A doua linie");
+    // buffer-ul este golit automat la închiderea resursei
+} catch (IOException e) {
+    e.printStackTrace();
+}
+</code>
+<note tip>
+Pentru scrierea fișierelor binare eficient puteți folosi ''BufferedWriterStream'' și ''FileWriterStream''.
+</note>
+=== ===
+<note important>
+Pentru clasele ''FileWriter'' / ''BufferedWriter'' / ''OutputStreamWriter'' / ''PrintWriter'':
+  * Dacă fișierul nu există, **Java îl creează automat**.
+  * Dacă fișierul există deja, **conținutul va fi suprascris**, cu excepția cazului când folosim constructorul cu ''append = true''.
+</note>
+===TL;DR - I/O Basics===
+^ Scenariu / Tip flux                 ^ Cum citim                                                                                              ^ Cum scriem                                                                                               ^
+| Fișier text mic                     | ''FileReader("fisier.txt")''                                                                             | ''FileWriter("fisier.txt")''                                                                               |
+| Fișier text mare / linie cu linie   | ''new BufferedReader(new FileReader("fisier.txt"))''                                                     | ''new BufferedWriter(new FileWriter("fisier.txt"))''                                                       |
+| Text cu encoding (UTF-8 etc.)       | ''new BufferedReader(new InputStreamReader(new FileInputStream("fisier.txt"), StandardCharsets.UTF_8))'' | ''new BufferedWriter(new OutputStreamWriter(new FileOutputStream("fisier.txt"), StandardCharsets.UTF_8))'' |
+| Input de la tastatură / conversie   | ''Scanner(System.in)''                                                                                   | –                                                                                                        |
+| Scriere text ușor formatat / raport | –                                                                                                      | ''PrintWriter(new BufferedWriter(new FileWriter("fisier.txt")))''                                          |
+====[Nice to know] File I/O - Advanced====
+===I/O Streams===
 Majoritatea operațiilor I/O în Java se bazează pe **fluxuri (streams)**.
@@ Line 539: / Line 799: @@
 </spoiler>
-===InputStream și OutputStream===
+==InputStream și OutputStream==
 Clasele [[https://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html | InputStream]] și [[https://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html | OutputStream]] sunt **abstracte** și definesc interfața de bază pentru toate fluxurile de bytes în Java. Ele oferă metode pentru **citirea și scrierea datelor nestructurate**, la nivel de byte.
@@ Line 547: / Line 807: @@
 {{ :poo-ca-cd:laboratoare:io_stream.png?450 |}}
-<spoiler [Opțional] Moștenirea claselor InputStream și OutputStream>
+<spoiler [Optional] Moștenirea claselor InputStream și OutputStream>
 Deoarece toate fluxurile de bytes moștenesc structura claselor InputStream sau OutputStream, diferitele tipuri de fluxuri pot fi folosite în mod **interschimbabil**.
@@ Line 559: / Line 819: @@
 </spoiler>
-==== Basic I/O ====
+===Basic I/O ===
 Input-ul standard pentru o aplicație în Java se bazează pe un obiect de tip ''InputStream'', similar cu ''stdin'' din C sau ''cin'' din C++. Acesta reprezintă o sursă de date ce provine din environment-ul în care lucrăm:
@@ Line 601: / Line 861: @@
 </note>
-==== Character Streams ====
+===Character Streams ===
 Pentru că ne dorim să lucrăm cu valori reprezentate ca text, în Java au fost introduse clasele [[https://docs.oracle.com/javase/8/docs/api/java/io/Reader.html | Reader]] și [[https://docs.oracle.com/javase/8/docs/api/java/io/Writer.html | Writer]] din pachetul ''java.io''.
@@ Line 643: / Line 903: @@
 </note>
-==== Stream Wrappers ====
+===Stream Wrappers ===
 Când dorim să facem mai mult decât citirea sau scrierea simplă a octeților sau caracterelor, putem folosi **fluxuri de tip filtru**.
@@ Line 665: / Line 925: @@
 ''BufferedInputStream'' citește anticipat și stochează date într-un buffer, ceea ce **reduce accesările directe la sursa reală** și **îmbunătățește performanța**.
-<spoiler [Nice to know] Cum funcționează buffer-ul intern>
+<spoiler Cum funcționează buffer-ul intern>
 **La citire**, buffer-ul este o zonă temporară de memorie unde sunt încărcate datele dintr-un flux, de exemplu un fișier. În loc să citim un caracter sau un byte la un moment dat, fluxul preia un bloc mare de date și **îl stochează în buffer**. Apelurile ulterioare la ''read()'' iau datele **direct din buffer**, fără a accesa imediat fișierul, ceea ce crește semnificativ performanța operațiilor de citire. Practic, bufferul **reduce numărul de accesări ale sursei de date**.
@@ Line 710: / Line 970: @@
 Codul nostru este acum optim, dar **doar dacă lucrăm cu STDIN, STDERR și STDOUT**. Dacă vrem să lucrăm cu fișiere avem nevoie de alte clase specializate.
 </note>
-====Clasa File ====
+=== Clasa File ===
 [[https://docs.oracle.com/javase/8/docs/api/java/io/File.html | java.io.File]] oferă un mod de a **accesa informații** despre un fișier sau un director din sistemul de fișiere.
@@ Line 764: / Line 1024: @@
 </note>
-==== File Stream ====
+=== File Stream ===
 Acum că ați înțeles ce este un fișier și cum îl puteți reprezenta cu clasa ''File'', este momentul să învățați cum să citiți și să scrieți efectiv date. În Java, pentru lucrul cu fișiere există două fluxuri fundamentale:
@@ Line 806: / Line 1066: @@
 </code>
-=== Cum scrieți date într-un fișier? ===
+== Cum scrieți date într-un fișier? ==
 Pentru scriere, folosiți ''FileOutputStream''. Dacă **fișierul nu există**, acesta este **creat automat**. Dacă **există**, conținutul este **suprascris**, cu excepția cazului în care folosiți constructorul cu flag-ul ''append'' (care va face textul să fie scris în continuare):
@@ Line 829: / Line 1089: @@
 </code>
-==== ====
+=== ===
 <note tip>
@@ Line 839: / Line 1099: @@
   * Pentru scriere formatată, folosiți ''PrintWriter''
 </note>
-====TL;DR I/O - Modalități de scriere și de citire a datelor====
-Modalități de citire:
-  * **Scanner** - Ideal pentru fișiere text simple, mai ales când trebuie să parsați cuvinte sau numere ușor.
-<code java>
-try (Scanner sc = new Scanner(new File("exemplu.txt"))) {
-    while (sc.hasNext()) {
-        System.out.println(sc.next());
-    }
-} catch (FileNotFoundException e) {
-    e.printStackTrace();
-}
-// citire de la tastatură
-try (Scanner sc = new Scanner(System.in)) {
-    System.out.print("Introdu un număr: ");
-    int numar = sc.nextInt();
-    System.out.println("Ai introdus: " + numar);
-}
-</code>
-  * **BufferedReader** - Recomandat pentru fișiere text mari, citește linie cu linie și este mai eficient.
-<code java>
-try (BufferedReader br = new BufferedReader(new FileReader("exemplu.txt"))) {
-    String linie;
-    while ((linie = br.readLine()) != null) {
-        System.out.println(linie);
-    }
-} catch (IOException e) {
-    e.printStackTrace();
-}
-// citire de la tastatură
-try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
-    System.out.print("Introdu un text: ");
-    String linie = br.readLine();
-    System.out.println("Ai scris: " + linie);
-} catch (IOException e) {
-    e.printStackTrace();
-}
-</code>
-  * **FileInputStream** - Potrivit pentru date binare (imagini, audio, PDF) sau când aveți nevoie de control asupra octeților.
-<code java>
-try (FileInputStream fis = new FileInputStream("imagine.jpg")) {
-    byte[] buffer = new byte[1024];
-    int bytesRead;
-    while ((bytesRead = fis.read(buffer)) != -1) {
-        // procesare date binare
-    }
-} catch (IOException e) {
-    e.printStackTrace();
-}
-</code>
-Modalități de scriere:
-  * **PrintWriter** - Ideal pentru fișiere text simple.
-<code java>
-try (PrintWriter pw = new PrintWriter(new FileWriter("exemplu.txt"))) {
-    pw.println("Salut!");
-    pw.println("Aceasta este o linie nouă.");
-} catch (IOException e) {
-    e.printStackTrace();
-}
-</code>
-  * **BufferedWriter** - Recomandat pentru fișiere text mari, citește linie cu linie și este mai eficient.
-<code java>
-try (BufferedWriter bw = new BufferedWriter(new FileWriter("exemplu.txt"))) {
-    bw.write("Prima linie");
-    bw.newLine();
-    bw.write("A doua linie");
-} catch (IOException e) {
-    e.printStackTrace();
-}
-</code>
-  * **FileOutputStream** - Potrivit pentru date binare (imagini, audio, PDF) sau când aveți nevoie de control asupra octeților.
-<code java>
-try (FileOutputStream fos = new FileOutputStream("imagine.jpg")) {
-    byte[] data = { /* octeți */ };
-    fos.write(data);
-} catch (IOException e) {
-    e.printStackTrace();
-}
-</code>
-====🎲 [Optional] RandomAccessFile ====
+===[Optional] RandomAccessFile ===
 Până acum am discutat despre fluxuri care citesc sau scriu date secvențial, de la începutul fișierului până la sfârșit. Dar ce faceți dacă aveți nevoie să accesați direct o anumită poziție/index din fișier? Pentru asta există clasa [[https://docs.oracle.com/javase/8/docs/api/java/io/RandomAccessFile.html|java.io.RandomAccessFile]], ce vă permite să citiți și să scrieți date oriunde în fișier. RandomAccessFile implementează interfețele ''DataInput'' și ''DataOutput'', ceea ce înseamnă că puteți folosi metodele pentru citirea și scrierea tipurilor primitive Java și a șirurilor, la fel ca în ''DataInputStream'' și ''DataOutputStream''. Totuși, nu este o subclasă a ''InputStream'' sau ''OutputStream'', deoarece oferă acces aleatoriu, nu secvențial.

Administrativ

Laboratoare

Teme

Resurse utile

Alte resurse

Arhiva laboratoare

Arhiva teme

Arhiva teste grila

Teste grilă

poo-ca-cd/laboratoare/io-si-gestionarea-exceptiilor.1763338775.txt.gz · Last modified: 2025/11/17 02:19 by florian_luis.micu

Show page Old revisions

Media Manager Back to top