-
Notifications
You must be signed in to change notification settings - Fork 0
/
tutorial-io
146 lines (119 loc) · 6.33 KB
/
tutorial-io
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
= Tutorial I/O =
* Responsabil: [[[email protected]|Mihai Burdușelu]]
* Data publicării: 01.10.2017
* Data ultimei modificări: 28.09.2017
==Obiective==
Scopul acestui tutorial este de a vă familiariza cu API-ul pus la dispoziție pentru citirea și scrierea în fișier. În cadrul laboratoarelor și temelor puteți importa acest API sau puteți sa folosiți o implementare proprie.
==Introducere==
Acest API se folosește de [[http://docs.oracle.com/javase/8/docs/api/?java/io/FileReader.html|java.io.FileReader]] pentru a crea un flux de intrare de caractere.
[[https://docs.oracle.com/javase/8/docs/api/java/io/BufferedReader.html|BufferedReader]] este responsabil cu preluarea datelor de la un flux primitiv (''FileReader'') și procesarea acestora pentru a le oferi într-o altă formă. Patternul //Decorator// este aplicat aici, intrucat ''BufferedReader'' este un wrapper peste ''FileReader''.
De asemenea, [[https://docs.oracle.com/javase/8/docs/api/java/io/FileWriter.html|java.io.FileWriter]] este responsabil pentru crearea unui flux de ieșire de caractere, în vreme ce [[https://docs.oracle.com/javase/8/docs/api/java/io/BufferedWriter.html|BufferedWriter]] este un wrapper peste acesta.
''BufferedReader'' are calitatea de a "buffera" fluxul de date. Astfel, această metodă de citire este mai eficientă decât folosirea directă a unui ''FileReader''.
==Importarea API-ului==
Acest API este livrat deja compilat sub formă de fișier JAR.
Importarea unui astfel de proiect este explicata în acest [[laboratoare:importare-fisiere-jar|tutorial]].
==Citirea dintr-un fișier text==
FileReader este clasa care manipulează operațiile de citire dintr-un fișier. Numele fișierului este pasat drept parametru către constructor.
<note>
Deschiderea fișierului se face în momentul instanțierii obiectului.
Dacă fișierul nu se află pe disc, API-ul va arunca FileNotFoundException.
</note>
===Instanțierea unui obiect al clasei FileReader===
<code java>
String filename = "input.txt";
FileReader fileReader = new FileReader(filename);
</code>
===Citirea tipurilor de date primitive din Java===
FileReader conține metode de citire a tipurilor de date primitive din Java: ''nextChar'', ''nextBool'', ''nextInt'', ''nextLong'', ''nextFloat'' și ''nextDouble''.
Exemplu de folosire a metodelor **next***
<code text input.txt>
4
3.14 true
</code>
<code java>
int integerNumber;
float floatingNumber;
boolean boolVariable;
integerNumber = fileReader.nextInt();
floatingNumber = fileReader.nextFloat();
boolVariable = fileReader.nextBool();
System.out.println(String.format("%d %f %b", integerNumber, floatingNumber, boolVariable));
</code>
În urma rulării codului de mai sus, se va afișa "//4 3.14 true//".
===Citirea stringurilor delimitate de spații===
De asemenea, API-ul oferă și metoda ''nextWord'' care are drept scop citirea unui string pană la întâlnirea primului spațiu.
Exemplu de folosire a metodei **nextWord**
<code text input.txt>
apples pears
</code>
<code java>
String firstWord, secondWord;
firstWord = fileReader.nextWord();
secondWord = fileReader.nextWord();
System.out.println(String.format("%s, %s", firstWord, secondWord));
</code>
În urma rulării codului de mai sus, se va afișa "//apples, pears//".
<note important>
**Atenție!** Odată cu apelarea metodelor next* se modifică automat și poziția pointerului din fișier.
Astfel, poziția la care ne aflam la un moment dat într-un fișier înaintează cu apelurile metodelor next*.
</note>
===Închiderea fișierului===
După terminarea operației de citire din fișier, fișierul de citire trebuie închis folosind metoda ''close()''.
==Scrierea în fișier==
FileWriter este clasa care manipulează operațiile de scriere într-un fișier. Numele fișierului este pasat drept parametru către constructor.
<note>
Deschiderea fișierului se face în momentul instanțierii obiectului.
Dacă fișierul nu se afla pe disc, acesta este creat automat.
</note>
===Instanțierea unui obiect al clasei FileReader===
<code java>
String filename = "output.txt";
FileWriter fileWriter = new FileWriter(filename);
</code>
===Scrierea principalelor tipuri de date din java===
FileWriter conține metode de **write***, complementare cu metodele **next*** din FileReader.
Metoda ''writeNewLine()'' trece pe o linie nouă în fișier.
Exemplu de folosire a metodelor **write***
<code java>
int number = 3;
float pi = 3.14;
String word = "apples";
fileWriter.writeInt(number);
fileWriter.writeNewLine();
fileWriter.writeWord(word);
fileWriter.writeFloat(pi);
</code>
În urma rulării codului de mai sus, fișierul de output va fi următorul:
<code text output.txt>
3
apples3.14
</code>
<note important>
**Atentie!** API-ul nu insereaza spatii intre doua apeluri successive de metode write*.
</note>
===Închiderea fișierului===
După terminarea operației de scriere în fișier, fișierul de scriere trebuie închis folosind metoda ''close()''.
==Abstractizare pentru manipularea ambelor fluxuri de date==
În cazul în care programul are nevoie atât de citire dintr-un fișier denumit input, cât și de scriere într-altul denumit output, API-ul oferă o abstractizare numită ''FileSystem''.
Cele 2 fișiere (input și output) sunt date drept parametri către constructor.
===Instanțierea unui obiect al clasei FileSystem===
<code java>
String input= "input.txt", output = "output.txt";
FileSystem fileSystem = new FileSystem(input, output);
</code>
===Citirea, respectiv scrierea principalelor tipuri de date din java===
Această abstractizare reunește metodele de tip next* pentru citire, respectiv write* pentru scriere ale claselor FileReader și FileWriter.
Exemplu de folosire a metodelor **next*** și **write***
<code java>
int number = fileSystem.nextInt();
fileSystem.writeInt(number);
</code>
În urma rulării codului de mai sus, se va citi un întreg din fișierul de input și va fi scris în fișierul de output.
===Închiderea fișierelor===
După terminarea operațiilor de citire, respectiv scriere, ambele fișiere trebuie închise folosind metoda **close()**.
==Alte modalități de a manipula fluxurile intrare-ieșire==
* [[https://docs.oracle.com/javase/7/docs/api/java/io/RandomAccessFile.html|RandomAccessFile]]
==Resurse==
* [[https://docs.oracle.com/javase/tutorial/essential/io/|Basic I/O]]
* {{laboratoare:tutorial-io:fileio.zip|FileIO}}
* {{laboratoare:tutorial-io:fileio_jar.zip|FileIO JAR}}