1. C12 – LPO: Operatii de Intrare/iEsire cu fisiere
CUPRINS
Fisiere
Fluxuri
pe octet
pe caracter
Serializare
Tokenizer (analiza lexicala)

2. Obiective După parcurgerea acestui curs ar trebuie sa puteţi:
înţelege principiile de lucru fisiere si fluxuri in Java;
manipula date date prin fluxuri pe caracter si octer;
serializa obiecte prin fluxuri;
realiza analiza lexicala a datelor stocate in fisiere.

3. Fisiere Java
fişierul este o structura de date ce asigura pastrarea permanenta (persistenta) datelor;
datele sunt stocate utilizând doua formate:
text (caracter) : ‘a’ ‘b’ ‘1’ ‘2’ ….
binar (octeti): …
în Java fişierele sunt fluxuri de caractere sau de octeti
fluxul este abstractizarea pentru orice se poate citi sau scrie;
clasele de fluxuri (Stream) se folosesc la manipularea de octeti, clasele Reader si Writer citesc si scriu caractere.

4. Fluxuri
operatiile de intrare/ieşire pe fluxuri au la baza patru clase abstracte: InputStream, OutputStream, Reader şi Writer;
pe baza acestora se creeaza mai multe clase concrete, de aplicatiile opereaza cu clase concrete, cele abstracte definesc functonalitatea comuna tuturor claselor din acea categorie;
InputStream şi OutputStream se folosesc în cazul fluxurilor de octeti, iar Reader şi Writer se folosesc în cazul fluxurilor de caractere;
fluxurile pe caracter se folosesc în cazul caracterelor şi a şirurilor de caractere, iar cele pe octet în cazul octetilor sau a obiectelor binare.

5. Fisiere externe si directori
un obiect din clasa File se foloseste pentru manipularea de fisiere si directori (la nivelul sistemului de operare);
crearea unui fisier extern si director se fac prin:
stergerea unui fisier sau director (se poate sterge doar daca e vid):
redenumirea unui fisier sau director:
alte metode:
f.getName():
f.getPath():
f.isFile() sau f.isDirectory()
f.canRead() sau f.canWrite():
File f = new File(“nume.txt”);
f.createNewFile();
File d = new File(“dir1);
d.mkdir();
f.delete();
f.renameTo();

6. Clase de fluxuri pe octet

7. FileInputStream si FileOutputStream
FileInputStream creeaza un InputStream ce se poate folosi pentru citirea de octeti din fisier;
FileOutputStream creeaza un OutputSteam ce se poate folosi pentru scrierea de octeti in fisier;
import java.io.*;
public class ByteStreamIO {
public static void main(String[] args) {
int nroct = 0;
int iout = 2807;
byte[] bout = new byte[2];
try {
FileOutputStream scriebin = new FileOutputStream("out.bin");
//transformat int-ul in byte-uri
bout[0] = (byte)(iout / 256); //10
bout[1] = (byte)(iout % 256); //247
scriebin.write(bout);
scriebin.close();
FileInputStream citestebin = new FileInputStream("out.bin");
nroct = citestebin.available();
System.out.println(nroct + " octeti.");
if (nroct > 0) {

8. FileInputStream si FileOutputStream
for (int i = 0; i < nroct; i++)
System.out.println(citestebin.read());
/* se poate si asa desi numarul
* de octeti se cunoaste
while ((bin = (byte)citestebin.read()) != -1)
System.out.println((int) bin); */ }
citestebin.close();
} catch (FileNotFoundException n) {
System.err.println("Nu pot lucra cu fiserul!");
} catch (IOException e) {
System.err.println("Eroarea de I/E: " + e);

9. Clase de fluxuri pe caractere

10. FileReader si FileWriter
FileWriter creeaza un Writer ce se poate folosi pentru scrierea de caractere in fisier;
FileReader creeaza un Reader ce se poate folosi pentru citirea de caratere din fisier;
import java.io.*;
public class CharStreamIO {
public static void main(String[] args) {
String s = "2807";
int nroct = 0, in;
try {
FileWriter scrietxt = new FileWriter("out.txt");
for(int i=0; i<s.length();++i)
scrietxt.write(s.charAt(i));
/* se poate scrie direct tot sirul cu:
scrietxt.write(s); */
scrietxt.flush(); // inainte de close nu e necesar
scrietxt.close();
FileReader citestetxt = new FileReader("out.txt");

11. FileReader si FileWriter
while ((in = citestetxt.read()) != -1) {
System.out.println((char)in);
nroct++; }
citestetxt.close();
} catch (IOException e) {
System.out.println("Eroarea de I/E: " + e);

12. Serializare
fluxurile de obiecte permit operatii de intrare si iesire la nivel de obiect;
pentru ca un obiect sa poata fi scris sau citit, clasa ce defineste obiectul trebuie sa implementeze interfata java.io.Serializable (sau java.io.Externalizable);
interfata Serializable are rol de marcare, nu are metode, deci nu se scrie cod aditional in clasa ce implementeaza Serializable;
implementarea interfetei premite ca mecanismul de serializare Java sa automatizeze procesul de stocare al obiectelor sau tablourilor.

13. Interfata Serializable
import java.io.Serializable;
public class Punct implements Serializable{
//Campuri
private double x;
private double y;
private double distanta;
//Constructori
Punct() {
setX(0);
setY(0);
distanta = 0; }
Punct(double x, double y) {
setX(x);
setY(y);
actualizareDistanta();
// Metode
public void setX(double x) {
this.x = x;
public void setY(double y) {
this.y = y;
public double x() {
return x; }
public double y() {
return y;
public double distantaOrigine() {
return distanta;
private void actualizareDistanta() {
distanta = Math.sqrt(x*x+y*y);
public String toString() {
return "<" + x + "," + y + ">";

14. Interfata Serializable
import java.io.*;
public class TestSerializare {
public static void main(String[] args) {
Punct p1 = new Punct(1,1);
Punct[] puncte = new Punct[3];
puncte[0]=p1;
puncte[1]= new Punct(2,2);
puncte[2]= new Punct(3,3);
ObjectOutputStream out;
ObjectInputStream in;
try {
out = new ObjectOutputStream(new FileOutputStream("obiecte.dat"));
out.writeObject(puncte);
out.close();
in = new ObjectInputStream(new FileInputStream("obiecte.dat"));
Punct [] punctecitie = (Punct []) in.readObject();
in.close();
for (Punct p: punctecitie)
System.out.println(p);
} catch (Exception e) { e.printStackTrace(); } }

15. Stream si String Tokenizer
SteamTokenizer formeaza atomi lexicali de pe InputStream delimitati prin anumite multimi de caractere, lucreaza similar cu StringTokenizer.
import java.io.*;
import java.util.StringTokenizer;
public class LineTokenStreamIO {
public static void main(String[] args) {
int l = 0;
String linie = null;
PrintWriter fout = null;
BufferedReader fin = null;
String s;
int x;
double y1, y2;
try {
fout = new PrintWriter(new FileWriter("linefile.txt"));
//scrierea datelor in fisier, separatorul este ","
for (int i = 0; i < 5; ++i)
fout.println("Linia " + (i + 1) + "," + i + "," + Math.sin(i) +
"," + Math.cos(i));
fout.close();
fin = new BufferedReader(new FileReader("linefile.txt"));
while ((linie = fin.readLine()) != null) {
System.out.println("S-a citit linia: "+linie);

16. //extragerea simbolurilor pe baza separatorului ,
StringTokenizer t = new StringTokenizer(linie,",");
s = t.nextToken();
x = Integer.parseInt(t.nextToken());
y1 = Double.parseDouble(t.nextToken());
y2 = Double.parseDouble(t.nextToken());
System.out.println(s+x+y1+y2);
++l; }
System.out.println("S-au citit si prelucrat" + l + " linii");
fin.close();
} catch (IOException e) {

17. Intrebari
Ce este persistenta datelor, cum se ajunge la aceasta prin fisiere?
Cate clase abstracte pentru lucrul cu fluxuri sunt in Java si cand se folosesc acestea?
Cu ce clasa se manipuleaza sistemul de fisiere (al sistemului de operare), ce operatii sunt posibile?
Ce presupune procesul de serializare al unei clase si ce effort de implementare necesita?
Ce este o clasa Tokenizer?

18. Bibliografie
Ştefan Tanasă, Cristian Olaru, Ştefan Andrei, Java de la 0 la expert, Polirom, 2003, ISBN:
Herber Schild, Java 2 - The Complete Reference, Fourth Edition, Osborne, 2001, ISBN:
Deitel H.M., Deitel P. J., Java - How to programm, Fith Edition, Prentice Hall, 2003, ISBN: