Platforma Java contine
trei clase care pot fi folosite pentru
lucrul cu date de tip (sir de) caractere:
- Character - clasa care
incapsuleaza o singura valoare caracter
- String - clasa care incapsuleaza un sir de caractere nemodificabil (immutable)
- StringBuffer - clasa care
incapsuleaza un sir de caractere
modificabil (mutable)
Clasa Character
incapsuleaza o singura valoare caracter, nemodificabila (immutable).
Caracterul incapsulat este astfel protejat, poate fi pasat in interiorul unui
obiect (accesat prin referinta), comparat, convertit. De asemenea, caracterului
ii poate fi determinat tipul (litera, numar, etc.).
Declaratiile de pachet si clasa ale clasei Character
sunt urmatoarele:
package
java.lang;
public
final class Character extends Object implements java.io.Serializable,
Comparable {
// corpul clasei Character
}
Constructorul clasei Character
:
|
Folosind urmatorul format de prezentare:
|
|
in continuare
sunt detaliate cateva dintre metodele declarate
in clasa Character
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Asadar, clasa Character permite:
- comparatii intre caractere (compareTo()
, equals()
, etc.),
- determinarea tipului de
caracter (isLetter()
, isDigit()
, isLowerCase()
, isUpperCase()
, etc.),
- conversii (toLowerCase()
,toUpperCase()
, toString()
, etc.).
Exemplu de utilizare a clasei Character:
public
class CharacterDemo {
public static void main(String args[]) {
Character a = new Character('a');
Character a2 = new Character('a');
Character b = new Character('b');
int difference = a.compareTo(b);
if (difference == 0) {
System.out.println("a este egal
cu b.");
} else if (difference < 0) {
System.out.println("a este mai
mic decat b.");
} else if (difference > 0) {
System.out.println("a este mai
mare decat b.");
}
System.out.println("a is " + ((a.equals(a2))
? "equal" : "not equal")
+ " to a2.");
System.out.println("Caracterul"
+ a.toString() + " este "
+ (Character.isUpperCase(a.charValue())
? "upper" : "lower") + "case.");
}
}
Rezultatul executiei
programului este urmatorul:
a este
mai mic decat b.
a este egal cu a2.
Caracterul a este lowercase.
Clasa String
incapsuleaza un sir de caractere, nemodificabil
(immutable). Sirul de caractere
incapsulat este astfel protejat, poate fi pasat in interiorul unui obiect
(accesat prin referinta), comparat, convertit la valori numerice sau la
tablouri de octeti sau caractere. De asemenea, caracterele pe care le contine
pot fi accesate individual.
Declaratiile de pachet si clasa ale clasei String
sunt urmatoarele:
package java.lang;
public final class String implements
java.io.Serializable, Comparable, CharSequence {
// corpul clasei String
}
Principalii constructori ai clasei String
:
|
|
|
|
|
|
|
Declaratiile si descrierea
catorva metode ale clasei String
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Se observa urmatoarele echivalente
functionale:
- constructorul String
(char[] value)
cu metoda static
String valueOf(char[] data)
:
|
|
- constructorul String
(char[] value, int offset,
int count)
cu metoda static
String valueOf(char[] value,
int offset, int count)
:
|
|
- constructorul String
(String original)
cu metoda String
toString()
, dar si cu alte metode:
|
|
Se observa si urmatoarele complementaritati
functionale:
- constructorul String
(byte[] bytes)
cu metoda byte[]
getBytes()
:
|
|
O parte din codul clasei String
:
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 |
public final class String { // finala - nu poate fi extinsa prin
mostenire private
char[] value; // tabloul de caractere care stocheaza
sirul private
int offset; //
indexul primei locatii utilizate pentru stocare private
int count; //
numarul de caractere al sirului //
Diferiti constructori String public
String() { value
= new char[0]; } public
String(String value)
{ count
= value.length(); this.value = new char[count]; value.getChars(0, count, this.value, 0); } public
String(char[] value) { this.count = value.length; this.value = new char[count]; System.arraycopy(value, 0, this.value, 0, count); } // Metode
publice, de obiect public boolean equals(Object obj) { if ((obj != null) && (obj instanceof
String)) { String
otherString = (String)obj; //
cast int n = this.count; if (n == otherString.count) { char v1[] = this.value; char v2[] = otherString.value;; int i = this.offset; int j = otherString.offset; while (n-- != 0) if (v1[i++] != v2[j++])
return false; return true; } } return false; } public int length() { return count; } public static String valueOf(int
i) { return Integer.toString(i, 10); } // ... multe alte metode } |
Exemple
de lucru cu obiecte de tip String
.
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 |
// variabile referinta String a; //
referinta la String initializata
implicit cu null String b = null; // referinta la String initializata
explicit cu null // constructie siruri de caractere utilizand
constructori String() String
sirVid = new String(); // sirVid.length
= 0, sirVid = ""
byte[] tabByte = {65, 110, 110, 97};
// coduri ASCII
String sirTablouByte = new String(tabByte); // sirTablouByte = "Anna"
char[] tabChar = {'T', 'e', 's', 't'};
String sirTabChar = new String(tabChar); // sirTabChar
= "Test"
String s = "Sir de caractere";
String sir = new String(s); // sir = "Sir de caractere" // constructie siruri de caractere utilizand metoda
toString() String sirCopie = sir.toString(); // constructie siruri de
caractere utilizand metode de clasa boolean
adevarat = true;
String sirBoolean = String.valueOf(adevarat); // sirBoolean = "true" // echivalent cu String sirBoolean =
String.valueOf(true);
char caracter = 'x';
String sirChar = String.valueOf(caracter); //
sirChar = "x"
char[] tab2Char = {'A', 'l', 't', ' ', 't', 'e', 's', 't'};
String sirTab2Char = String.valueOf(tab2Char); // sirTabChar2="Alt test"
int numar = 10000;
String sirInt = String.valueOf(numar); // sirInt = "1000"
double altNumar = 2.3;
String sirDouble = String.valueOf(altNumar); // sirDouble = "2.3" // conversia sirurilor de caractere la alte tipuri String
sirTest = "ABC abc";
byte[] sirTestByte = sirTest.getBytes(); // coduri ASCII
System.out.print("sirTestByte = ");
for (int i=0; i < sirTestByte.length; i++)
System.out.print(sirTestByte[i] + " ");
System.out.println();
char[] sirTestChar = sirTest.toCharArray(); //
caractere UNICODE
System.out.print("sirTestChar =
");
for (int i=0; i < sirTestChar.length; i++)
System.out.print(sirTestChar[i] + " ");
System.out.println(); // concatenare String f = "Sir " + "de " + "caractere";
//
echivalent cu: String f = "Sir de
caractere"; |
Clasa StringBuffer
incapsuleaza siruri
de caractere modificabile (mutable).
Un sir de caractere modificabil este asemanator unui String
, dar continutul lui poate fi modificat.
In orice moment el contine un anumit sir de
caractere, dar lungimea si continutul
sirului pot fi modificate prin apelul anumitor metode.
Sirurile de caractere modificabile (StringBuffer
) sunt sigure din punct de vedere al programelor multifilare (multithreaded). Metodele clasei StringBuffer
sunt implicit sincronizate atunci cand e necesar, astfel incat
toate operatiile asupra oricarei instante se desfasoara ca si cum ar aparea
intr-o ordine seriala (secventiala) consistenta cu ordinea in care apelurile
sunt facute de fiecare fir (thread)
individual implicat.
Declaratiile de pachet si clasa ale clasei StringBuffer
sunt urmatoarele:
package java.lang;
public final
class StringBuffer implements
java.io.Serializable, CharSequence {
// corpul clasei StringBuffer
}
Constructorii
clasei StringBuffer
:
|
|
|
Declaratiile si descrierea catorva metode ale clasei StringBuffer
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Sirurile de caractere modificabile (StringBuffer
) sunt utilizate de compilator pentru a implementa operatorul + de concatenare binara a sirurilor. De exemplu, codul:
|
|
este compilat ca:
|
|
adica:
- se creaza un nou sir de caractere
modificabil (StringBuffer
), initial gol,
- se adauga la sirul de caractere
modificabil (StringBuffer
) reprezentarea sir de caractere (String
) a fiecarui operand, si apoi
- se converteste continutul sirului
de caractere modificabil (StringBuffer
) la un sir de caractere (String
).
In acest fel se evita crearea
temporara a mai multor obiecte String
.
Principalele operatii asupra unui StringBuffer sunt
- adaugarea la sfarsitul sirului
modificabil curent (metoda append()) si
- inserarea intr-o pozitie
specificata in sirul modificabil curent (metoda insert()),
al caror nume sunt supraincarcate astfel incat accepta date de orice tip.
In general, daca sb este o instanta StringBuffer, atunci sb.append(x) are acelasi efect ca sb.insert(sb.length(), x).
Utilizarea metodei insert():
StringBuffer sb = new StringBuffer("Drink Java!");
sb.insert(6, "Hot ");
System.out.println(sb.toString());
Rezultatul executiei programului este urmatorul:
Drink Hot Java!
Fiecare
sir de caractere modificabil are o capacitate. Cat timp lungimea
sirului de caractere continut nu depaseste capacitatea, nu este necesara
alocarea unui nou tablou de caractere intern. Daca este depasita capacitatea acestui tablou, el
este in mod automat largit.
Program
de inversare a unui sir folosind String
si StringBuffer
:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
class ReverseString { public static String reverseIt(String source) { int i, len = source.length(); StringBuffer dest = new StringBuffer(len); for (i = (len - 1); i >= 0; i--) dest.append(source.charAt(i)); return dest.toString(); } } public class StringsDemo { public static void main(String[] args) { String palindrome = "Dot saw I was Tod"; String reversed = ReverseString.reverseIt(palindrome); System.out.println(reversed); }
} |
Rezultatul executiei programului este urmatorul:
doT saw I was toD
Utilizarea metodei valueOf():
String piStr = "3.14159";
Float pi = Float.valueOf(piStr);
Ca si caracterele, si tipurile primitive
numerice pot fi incapsulate in obiecte al caror continut este nemodificabil (immutable) dupa initializare. Iata, mai jos, o parte din ierarhia de
clase Java.
Vom analiza clasa Integer, care
incapsuleaza valori intregi primitive de tip Integer. Celelalte clase care incapsuleaza valori numerice primitive (Byte, Short, Long, Float, Double) si clasa care incapsuleaza valori logice
primitive (Boolean) au o interfata si un mod de lucru
asemanator.
Clasa Integer permite
incapsularea valorilor primitive de tip int in obiecte, dar si conversia intre intregi si alte tipuri primitive. Un
obiect de tip Integer contine un singur atribut (camp) al carui
tip este int
.
Declaratiile de pachet si clasa ale clasei Integer
sunt urmatoarele:
package
java.lang;
public final
class Integer extends Number
implements Comparable {
// corpul clasei Integer
}
Constructorii clasei Integer
:
|
|
Declaratiile si descrierea catorva metode ale clasei Integer
:
|
|
|
Altfel, metoda arunca o exceptie de tipul |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Metodele clasei Integer permit:
- incapsularea valorilor intregi
primitive (folosind constructori, dar si metode de clasa valueOf()
),
- comparatii intre intregi (compareTo()
, equals()
, etc.),
- conversii la tipuri numerice
primitive (byteValue()
, doubleValue()
, etc.),
- conversii la siruri de
caractere (toString()
, toBinaryString()
, etc.),
- conversii ale sirurilor de
caractere la valori intregi primitive (cu metoda de clasa parseInt()
).
Si celelalte
clase care incapsuleaza valori numerice primitive au metode similare metodei parseInt()
a clasei Integer, cu ajutorul carora pot crea valori
numerice primitive din reprezentarile sub forma de siruri de caractere ale
valorilor literale. Clasa Byte are o metoda de
clasa parseByte()
care primeste ca parametru un sir de caractere si
returneaza valoarea numerica primitiva de tip byte corespunzatoare, clasa Short are o metoda de
clasa parseShort()
,
clasa Long are o metoda de clasa parseLong()
, clasa Float are o metoda de clasa parseFloat()
, clasa Double are o metoda de clasa parseDouble()
, clasa Boolean are o metoda de clasa parseBoolean()
.
Apelul metodei parseInt() poate genera exceptie de tip NumberFormatException in cazul in care argumentul nu are format intreg. In acest caz, trebuie tratata exceptia de tip NumberFormatException, definita in clasa cu acelasi nume din
pachetul java.lang, cu ajutorul unui bloc de tip:
try { /* secventa care poate genera exceptia */
}
catch (NumberFormatException ex) {/* secventa care trateaza exceptia */
}
Ca in cazul programului urmator:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class AfisareArgumenteProgramIntregi2 { public static void main(String[] args) { int i; for ( i=0; i < args.length; i++ ) { try { System.out.println(Integer.parseInt(args[i])); } catch (NumberFormatException ex) { System.out.println("Argumentul
'" + args[i] +
"' nu are format numeric intreg"); } } } } |
Alte exemple
de lucru cu obiecte de tip Integer.
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 |
int
i, j, k; // intregi ca variabile de tip primitiv Integer m, n, o; // intregi incapsulati in obiecte Integer String
s, r, t; // siruri de caractere (incapsulate in
obiecte) // constructia
intregilor incapsulati // utilizand
constructori ai clasei Integer - 2 variante i = 1000; m = new Integer(i); // echivalent cu m = new Integer(1000); r = new String("30"); n = new Integer(r); // echivalent cu n = new Integer("30"); // constructia
intregilor incapsulati
// utilizand metode de clasa ale clasei Integer t = "40"; o = Integer.valueOf(t); // echivalent
cu o =
new Integer("40"); // conversia
intregilor incapsulati la valori numerice primitive byte iByte = m.byteValue();
// diferit de 1000! (trunchiat) short iShort = m.shortValue(); // = 1000 int
iInt = m.intValue(); // = 1000 long
iLong = m.longValue(); //
= 1000L float iFloat = m.floatValue(); // = 1000.0F double iDouble = m.doubleValue(); // = 1000.0 // conversia
intregilor incapsulati la obiecte sir de caractere String iString = m.toString(); //
metoda de obiect (non-statica) // conversia
valorilor intregi primitive la siruri de caractere String douaSute =
Integer.toString(200); //
metoda de clasa (statica) String oMieBinary = Integer.toBinaryString(1000); // metoda de clasa String oMieOctal = Integer.toOctalString(1000); //
metoda de clasa String oMieHex = Integer.toHexString(1000); // metoda de clasa // conversia
sirurilor de caractere la valori intregi primitive int oSuta = Integer.parseInt("100"); // metoda de clasa (statica) |
Programele pot avea nevoie de a:
·
prelua informatii
de la surse externe, sau
·
trimite informatii catre
destinatii externe.
Sursa/destinatia poate fi: fisier
pe disc, retea, memorie (alt program), dispozitive IO standard (ecran,
tastatura).
Tipurile informatiilor sunt diverse:
caractere, obiecte, imagini, sunete.
Pentru preluarea informatiilor programul deschide un flux de la o sursa de informatii si citeste serial (secvential)
informatiile, astfel:
Figura 1. Fluxuri de intrare (citire)
Java
Pentru trimiterea informatiei programul deschide un flux catre o destinatie de
informatie si scrie serial (secvential)
informatiile, astfel:
Figura 2. Fluxuri de iesire (scriere)
Java
In functie de tipul
de date transferate, clasele din pachetul java.io
se impart in:
·
fluxuri de caractere (date reprezentate in
UNICODE pe 16b), avand ca radacini
ale arborilor de clase derivate superclasele abstracte Reader (de intrare)
si Writer (de
iesire)
·
fluxuri de octeti (date reprezentate pe 8b), avand ca radacini ale arborilor de
clase derivate superclasele abstracte InputStream (de intrare) si OutputStream (de iesire)
Constructorii
clasei Reader
:
|
|
|
|
Constructorii
clasei Writer
:
|
|
|
|
Declaratiile si descrierea
catorva metode ale clasei Reader
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Declaratiile si descrierea
catorva metode ale clasei Writer
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Toate metodele au caracter public
si arunca exceptia IOException
.
Constructorul clasei InputStream
:
|
Constructorul clasei OutputStream
:
|
Declaratiile si descrierea
catorva metode ale clasei InputStream
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Declaratiile si descrierea
catorva metode ale clasei OutputStream
:
|
|
|
|
|
|
|
|
|
|
In functie de specializarea pe care o implementeaza, subclasele claselor abstracte Reader, Writer, InputStream, si OutputStream se impart in doua categorii:
- fluxuri terminale (data sink), care
nu au ca sursa / destinatie alte fluxuri,
ci:
- fisierele,
- memoria (tablourile),
- reteaua (socketurile),
- sirurile de caractere (String),
- alte programe (prin conducte - pipes)
- fluxuri de prelucrare (processing), care au ca sursa / destinatie alte fluxuri, si au ca rol prelucrarea
informatiilor:
- buffer-are (stocare temporara),
- filtrare de diferite tipuri (conversie,
contorizare, etc.)
- tiparire.
Mai jos sunt prezentate tipurile de fluxuri Java terminale.
Tip de Terminal |
Utilizare |
Fluxuri de caractere |
Fluxuri de octeti |
Memorie |
Accesul secvential la tablouri |
CharArrayReader |
ByteArrayInputStream |
CharArrayWriter |
ByteArrayOutputStream |
||
Accesul secvential la siruri de
caractere |
StringReader |
StringBufferInputStream |
|
StringWriter |
StringBufferOutputStream |
||
Canal / conducta (pipe) |
Conducte intre programe |
PipedReader |
PipedInputStream |
PipedWriter |
PipedOutputStream |
||
Fisier |
Accesul la fisiere |
FileReader |
FileInputStream |
Un ByteArrayInputStream contine un buffer (tablou de octeti) intern care
contine octetii ce pot fi cititi din flux (sursa fluxului este tabloul de octeti intern). Un
contor intern este utilizat pentru a determina care este urmatorul octet ce
trebuie oferit metodei read().
Inchiderea unui ByteArrayInputStream nu are nici un efect
vizibil. Metodele acestei
clase pot fi apelate si dupa ce fluxul a fost inchis, fara a se genera o
exceptie IOException.
Constructorii clasei ByteArrayInputStream
:
|
|
Declaratiile si
descrierea catorva metode ale clasei ByteArrayInputStream
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Un ByteArrayOutputStream
este un flux de iesire al octetilor care scrie datele intr-un tablou de
octeti intern (destinatia
fluxului este tabloul de octeti intern). Datele pot fi
regasite utilizand metodele toByteArray() (care returneaza tabloul de octeti) si toString().
Inchiderea unui ByteArrayOutputStream
nu are nici un efect
vizibil. Metodele acestei
clase pot fi apelate si dupa ce fluxul a fost inchis, fara a se genera o
exceptie IOException.
Constructorii clasei ByteArrayOutputStream
:
|
|
Atributele clasei ByteArrayOutputStream
:
|
|
|
|
Declaratiile si
descrierea catorva metode ale clasei ByteArrayOutputStream
:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
In continuare sunt ilustrate:
- citirea dintr-un fisier prin
intermediul unui flux de caractere
(Unicode!):
1 2 3 4 5 6 7 8 9 10 11 |
// Crearea unui obiect referinta la fisier pe baza numelui fisierului
File inputFile = new File(“nume1.txt”); // Crearea unui flux de intrare a
caracterelor dinspre fisierul dat
FileReader in = new
FileReader(inputFile); // Citirea unui caracter din fisier
int c = in.read(); // Input // Inchiderea fisierului
in.close(); |
- scrierea intr-un fisier prin
intermediul unui flux de caractere:
1 2 3 4 5 6 7 8 9 10 11 12 |
// Crearea unui obiect referinta la fisier pe baza numelui fisierului
File outputFile = new File(“nume2.txt”); // Crearea unui flux de iesire a
caracterelor spre fisierul dat
FileWrite out = new
FileWriter(outputFile);
char c = ‘x’; // Scrierea unui caracter in fisier out.write(c); //
Output // Inchiderea fisierului out.close(); |
Mai jos sunt prezentate tipurile de fluxuri Java de prelucrare.
Tip de Prelucrare |
Utilizare |
Fluxuri de Caractere |
Fluxuri de octeti |
Buffer-are |
Stocare temporară |
BufferedReader |
BufferedInputStream |
BufferedWriter |
BufferedOutputStream |
||
Filtrare |
Prelucrare |
FilterReader |
FilterInputStream |
FilterWriter |
FilterOutpuStream |
||
Conversie
octet/caracter |
Bridge byte-char |
InputStreamReader |
|
OutputStreamWriter |
|||
Concatenare |
Prelucrare |
|
SequenceInputStream |
Serializarea
obiectelor |
ObjectInputStream |
||
ObjectOutputStream |
|||
Conversia datelor |
Acces la tip date primitiv Java |
|
DataInputStream |
DataOutputStream |
|||
Numararea
(contorizarea) |
Numarare linii |
LineNumberReader |
LineNumberInputStream |
Testare |
Buffer de 1 byte/char |
PushBockReader |
PushbackInputStream |
Imprimare |
Tiparire |
PrintWriter |
PrintStream |
Un BufferedReader
citeste caracterele din fluxul din amonte (primit ca parametru de constructor in momentul
initializarii) si le stocheaza temporar
pentru a fi citite eficient caractere,
tablouri sau linii de text.
Constructorii clasei BufferedReader
:
|
|
Metoda oferita de clasa BufferedReader
pentru citirea liniilor de text este:
|
|
Un InputStreamReader
este un bridge
(convertor) de la octeti la caractere. El citeste octetii din fluxul din
amonte (primit ca parametru de constructor in momentul initializarii) si ii
decodeaza folosind un set de caractere dat (charset). Daca nu este specificat un set anume, este folosit in mod implicit cel
implicit al platformei pe care se lucreaza.
Constructorul tipic al clasei InputStreamReader
este:
|
Pentru eficienta maxima,
este recomandata inlantuirea (plasarea in cascada) a
unui InputStreamReader
si a unui BufferedReader
. De exemplu:
BufferedReader
in = new BufferedReader(new InputStreamReader(System.in));
O utilizare tipica a fluxurilor
de prelucrare BufferedReader
si InputStreamReader
plasate in cascada,
este cea care permite citirea sirurilor
de caractere de la consola standard de intrare (tastatura, care este incapsulata in obiectul System.in
, al carui tip este InputStream
- flux
de intrare a octetilor).
Exemplu de citire a unui nume de la tastatura:
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
System.out.println(“Introduceti numele: ”);
String nume = in.readLine();
Un BufferedWriter stocheaza temporar caracterele ce urmeaza a fi scrise in fluxul din
aval (primit ca parametru de constructor in
momentul initializarii) pentru a fi scrise
eficient caractere, tablouri sau siruri
de caractere.
Constructorii clasei BufferedWriter:
|
|
Metoda oferita de
clasa BufferedWriter pentru scrierea
separatorilor de linie de text este:
|
|
Un OutputStreamWriter este un bridge
(convertor) de la caractere la octeti. El scrie in fluxul din aval (primit
ca parametru de constructor in momentul initializarii) octeti obtinuti prin
codarea caracterelor, folosind un set de caractere dat (charset). Daca nu este specificat un set anume, este folosit in mod implicit cel
implicit al platformei pe care se lucreaza.
Constructorul tipic al clasei OutputStreamWriter
este:
|
Pentru eficienta maxima,
este recomandata inlantuirea (plasarea in cascada) a
unui OutputStreamWriter
si a unui BufferedWriter. De exemplu:
BufferedWriter
out = new BufferedWriter (new OutputStreamWriter
(System.out));
Constructorul tipic al clasei PrintStream
este:
|
Metodele oferite de clasa PrintStream
pentru
afisarea sirurilor de caractere (scrierea intr-un flux de iesire a octetilor a
sirurilor de caractere care cuprind si caractere escape) sunt:
|
|
|
… (Similar pentru celelalte tipuri de
date primitive Java: char, double, float, int, …) |
|
|
|
|
|
|
|
… (Similar pentru celelalte tipuri de
date primitive Java: char, double, float, int, …) |
|
|
O utilizare tipica acestui fluxuri de prelucrare este cea care permite scrierea sirurilor de caractere la consola standard de iesire (monitorul,
care este incapsulat intr-un OutputStream
ce serveste ca destinatie obiectului System.out
, al carui tip este PrintStream
).
Exemplu: afisarea argumentelor programului curent:
PrintStream
ps =
System.out;
ps.println(“Argumentele
programului: ”);
for (int i=0; i<args.length; i++) {
ps.print(args[i] + “ ”);
}
ps.println();
DataInputStream
)Clasa DataInputStream
permite citirea datelor
formatate (ca tipuri primitive) de la fluxul de intrare a octetilor primit
ca parametru in momentul constructiei (fluxul din amonte).
Constructorul clasei DataInputStream
este:
|
Metodele oferite de clasa DataInputStream
pentru citirea datelor formatate (ca tipuri primitive) de la fluxul de intrare
a octetilor primit ca parametru in momentul constructiei sunt:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Exemplu: citirea unui nume de la tastatura:
DataInputStream
in = new DataInputStream
(new BufferedInputStream(System.in));
System.out.println(“Introduceti numele: ”);
String nume = in.readLine();
DataOutputStream
)Clasa DataOutputStream
permite scrierea datelor formatate (ca tipuri primitive) in fluxul
de iesire a octetilor primit ca parametru in momentul constructiei (fluxul din
aval).
Constructorul clasei DataOutputStream
este:
|
Metodele oferite de clasa DataOutputStream
pentru scrierea datelor formatate (ca tipuri primitive) in fluxul de iesire a
octetilor primit ca parametru in momentul constructiei (din aval) sunt:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Exemplu: Afisarea argumentelor programului curent:
DataOutputStream
dos = new DataOutputStream
(System.out);
dos.writeBytes(“Argumentele
programului: \n”);
for (int i=0;
i<args.length; i++) {
dos.writeBytes(args[i] + “ ”);
}
dos.writeChar(‘\n’);
dos.flush();
Scrierea intr-un fisier cu DataOutputStream
:
DataOutputStream dos = new
DataOutputStream(new FileOutputStream(“invoice.txt”));
for ( i=0;i<price.length;i++ ) {
dos.write Double( price[i] ); //preturi
dos.write Char( `\t` ); //tab
dos.write
Int( units[i] ); //bucati
dos.write
Char( `\t` ); //tab
dos.write
Chars( desers[i] ); //articole
dos.write
Char( `\u` ); } //linie
noua
}
Continutul lui invoice.txt este:
10.5 10 ………
20.5 15 ………
….. …. ………
Citirea dintr-un fisier cu DataInputStream
:
DataInputStream
dis = new DataInputStream(new FileInputStream (“invoice.txt”));
try { while(true){
price
= dis.readDouble( ); // pret
dis.readChar(
); // salt peste tab
unit
= dis.readInt( ); // bucati
dis.readChar(
); // salt peste tab
desc
= dis.readLine( ); // articol
System.out.println(“ Ati comandat” + unit + “bucati de” +
desc );
total
= total + unit * price;
}
}
catch ( EOF Exception e )
{ }
System.out.println(
“Pentru un pret total de $” + total );
dis.close( );
while (( input = dis.readline( )) != null ) {
// ………
}
Rezultat
Ati comandat 10
bucati de …. la $10.5
Ati
comandat 15 bucati de …. la $20.5
…………..
Pentru
un pret total de: $ …..