1

Prezentare 16:
Streams –
elemente de
baza
PROGRAMARE ORIENTATA
OBIECT
2020
 Streams

 O adaugare la Java API care permite manipularea colectiilor in

mod declarativ – se exprima o interogare in locul unei implementari
ad-hoc a ei
Exemplu – numele felurilor cu putine calorii, sortate dupa numarul
de calorii
Java 7
List<Fel> feluriNecalorice = new ArrayList<>();
for (Fel fel: meniu) { filtrarea elementelor folosind un
acumulator
if(fel.getCalorii() < 500) {
feluriNecalorice.add(fel);
}
}
13.01.2021 POO 2
 Streams

Collections.sort(feluriNecalorice, new Comparator<Fel>() { sortare folosind o clasa

public int compare(Fel fel1, Fel fel2) { anonima
return Integer.compare(fel1.getCalorii(), fel2.getCalorii());
}
});

List<String> numeFeluriNecalorice = new ArrayList<>();

Parcurgerea listei sortate
for (Fel fel: feluriNecalorice) { pentru a selecta numele
numeFeluriNecalorice.add(fel.getNume()); felurilor
}

13.01.2021 POO 3
 Streams
Java 8++
import static java.util.Comparator.comparing; selecteaza feluri cu
import static java.util.stream.Collectors.toList; < 500 calorii
List<String> numeFeluriNecalorice = meniu.stream()
.filter(f -> f.getCalorii() < 500)
.sorted(comparing(Fel::getCalorii))
.map(Fel::getNume)
sorteaza dupa
stocheaza numele in lista .collect(toList()); calorii

extrage numele felurilor

13.01.2021 POO 4
 Streams

 Pentru o arhitectura multicore si executarea codului in paralel,

se inlocuieste stream() cu parallelStream()

List<String> numeFeluriNecalorice = meniu.parallelStream()

.filter(d -> d.getCalorii() < 500)
.sorted(comparing(Fel::getCalorii))
.map(Fel::getNume)
.collect(toList());

13.01.2021 POO 5
 Streams

 Codul este scris declarativ: specificam ce vrem sa obtinem (feluri cu

putine calorii), NU cum implementam operatia
 Se pot inlantui operatii pentru a obtine un pipeline de procesare.
Rezultatul lui filter este transferat metodei sorted, care apoi este
transferat metodei map si apoi metodei collect

lambda lambda lambda

meniu filter sorted map collect

13.01.2021 POO 6
 Streams

 Un stream este o secventa de elemente dintr-o sursa asupra carora

se pot aplica operatii de prelucrare a datelor
 secventa de elemente – asemenea colectiilor, un stream ofera o

interfata pentru o multime de valori avand un anumit tip;

colectiile sunt structuri de date, in timp ce streams exprima
operatii (filter, sorted, map)
 sursa – streams prelucreaza date dintr-o sursa (colectii, arrays,

resurse I/O)
 operatii de prelucrare a datelor – suporta operatii similare

bazelor de date sau a celor din limbajele functionale pentru

manipularea datelor: filter, map, reduce, find, match, sort

13.01.2021 POO 7
 Streams

 Caracteristici ale operatiilor

 pipelining

 iteratii interne obtinerea unui

stream din meniu
creeaza un
import static java.util.stream.Collectors.toList; pipeline de
operatii
List<String> treiNumeFeluriCalorice = meniu.stream()
.filter(f -> f.getCalorii() > 300)
.map(Fel::getNume) obtine numele felurilor
.limit(3)
.collect(toList());
System.out.println(treiNumeFeluriCalorice); Selecteaza doar
primele trei
colecteaza in
alta lista
13.01.2021 POO 8
 Streams
meniu stream
Stream<Fel>

filter(f->f.getCalorii()>300)
Stream<Fel>

map(Fel::getNume)
Stream<String>

limit(3)
Stream<String>

collect(toList())
List<String>

13.01.2021 POO 9
 Streams vs colectii

 O colectie este o structura in memorie care pastreaza toate valorile

curente ale structurii de date – fiecare element al colectiei trebuie
calculat inainte de a fi adaugat colectiei
 Un stream este conceptual o structura de date fixa (nu pot fi
adaugate sau eliminate elemente) ale carui elemente sunt calculate
la cerere
 o cautare pe google cu multe rezultate – este intors un stream cu
primele 20 potriviri impreuna cu un buton pentru a obtine
urmatoarele 20; atunci cand sunt cerute urmatoarele 20, sunt
calculate la cerere

13.01.2021 POO 10
 Streams vs colectii

 Streams pot fi parcurse o singura data

List<String> titlu = Arrays.asList(“Exemple”, “streams”, “in”, “java”);

Stream<String> s = titlu.stream();
afiseaza fiecare
s.forEach(System.out::println);
cuvant din titlu
s.forEach(System.out::println);

Java.lang.IllegalStateException: stream has already

been operated upon or closed

13.01.2021 POO 11
 Streams vs colectii

 Iteratii externe vs interne

 Iteratie externa – utilizarea interfetei Collection impune ca

iteratia sa fie facuta explicit de utilizator (for-each)

List<String> nume = new ArrayList<>(); itereaza explicit

for(Fel fel : meniu) { lista meniului
nume.add(fel.getNume()); secvential
}

extrage numele si il adauga la

acumulator

13.01.2021 POO 12
 Streams vs colectii

De fapt:

List<String> nume = new ArrayList<>();

Iterator<String> iterator = meniu.iterator(); itereaza explicit
while(iterator.hasNext()) { lista meniului
Fel fel = iterator.next(); secvential
nume.add(fel.getNume());
}

14.01.2021 POO 13
 Streams vs colectii

 Iteratii externe vs interne

 iteratie interna – biblioteca Streams face iteratia implicit si

stocheaza rezultatul

List<String> nume = meniu.stream() parametrizeaza

map cu getNume
.map(Fel::getNume) pentru a extrage
.collect(toList); numele unui fel

incepe executarea pipeline-

ului de operatii; fara iteratii

13.01.2021 POO 14
 Streams vs colectii
Streams – iteratii interne

Elemente
Cod

Colectii – iteratii externe

Elemente
Cod

14.01.2021 POO 15
 Operatii

 Exemplu iteratii interne vs externe

List<String> feluriCalorice = new ArrayList<>();
Iterator<String> iterator = meniu.iterator();
while (iterator.hasNext()) {
Fel f = iterator.next();
if (f.getCalorii() > 500) {
feluriCalorice.add(f.getNume());
}
}

List<String> feluriCalorice = meniu.stream()

.filter(f -> f.getCalorii() > 500)
.collect(toList());

14.01.2021 POO 16
 Operatii

 Interfata java.util.stream.Stream
 operatii intermediare - pot fi conectate pentru a forma un pipeline

 operatii finale – produc un rezultat dintr-un pipeline

15.01.2021 POO 17
 Operatii

List<String> treiNumeFeluriCalorice = meniu.stream()

.filter(f -> f.getCalorii() > 300)
.map(Fel::getNume)
.limit(3)
.collect(toList());

lambda lambda lambda

meniu filter map limit collect

operatii operatii
intermediare finale
14.01.2021 POO 18
 Operatii

 Operatii intermediare
 intorc ca rezultat un alt stream -> permite conectarea operatiilor

pnetr a forma o interogare

 nu realizeaza nicio prelucrare pana la invocarea unei operatii finale

– comportament lazy

13.01.2021 POO 19
 Operatii

List<String> nume =
meniu.stream()
.filter(f -> {
afiseaza felurile pe masura System.out.println(“filtare” + f.getNume());
ce sunt filtrate return f.getCalorii() > 300;
})
.map(f -> {
System.out.println(“map” + f.getNume());
return f.getNume();
afiseaza felurile pe masura
}) ce sunt extrase numele
.limit(3)
.collect(toList());
System.out.println(nume);

13.01.2021 POO 20
 Operatii

 Se va afisa:
filtrare:porc
map:porc
filtrare:pui
map:pui
filtrare:peste
map:peste
 Sunt realizate optimizari pe baza naturii lazy a stream-urilor

13.01.2021 POO 21
 Operatii

 Operatii finale
 produc rezultatul unui pipeline – o valoarea care nu este un stream:

List, Integer, void, etc

meniu.stream.forEach(System.out.println);

afiseaza fiecare fel din stream-ul

create pentru meniu

13.01.2021 POO 22
 Utilizare streams

 Presupune:
 o sursa de date (colectie) asupra careia se face interogarea

 un lant de operatii intermediare care formeaza pipeline-ul

 o operatie finala care executa pipeline-ul si produce rezultatul

13.01.2021 POO 23
 Utilizare streams

Operatie Tip Rezultat Argument Descriere

filter intermediara Stream<T> Predicate<T> T -> boolean
map intermediara Stream<R> Function<T, R> T -> R
limit intermediara Stream<T>
sorted intermediara Stream<T> Comparator<T>
distinct intermediara Stream<T>

Operatie Tip Rezultat Scop

forEach finala void consuma fiecare element din
stream si aplica o lambda
count finala long intorce numarul elementelor din
stream
collect finala (generic) reduce stream-ul pentru a crea o
colectie: List, Map, Integer
13.01.2021 POO 24
 Utilizare streams

 Filtrare
 filtrare prin predicat – metoda filter

List<String> meniuVeget = meniu.stream()

.filter(Fel::eVeget()) Utilizeaza referinta
la metoda
.collect(toList());
 filtrare elemente unice – metoda distinct – intoarce un stream cu
elemente unice
List<Integer> numere = arrays.asList(1,2,3,3,2,4,5);
numere.stream()
.filter(i -> i%2 == 0)
.distinct()
.forEach(System.out::println);
14.01.2021 POO 25
 Utilizare streams

 Selectie
 selectie prin predicat – metodele takeWhile si dropWhile

Exemplu – selectia felurilor de mancare cu mai putin de 400 calorii

din lista meniuSpecial ordonata crescator dupa calorii
 solutie bazata pe filter
List<String> meniuFiltrat = meniuSpecial.stream()
.filter(f -> f.getCalorii() < 400)
.collect(toList());

itereaza prin toata

lista

14.01.2021 POO 26
 Utilizare streams
 takeWhile
List<String> meniuFiltrat = meniuSpecial.stream()
.takeWhile(f -> f.getCalorii() < 400)
.collect(toList());
Exemplu – felurile cu mai mult de 400 calorii
 dropWhile

List<String> meniuFiltrat = meniuSpecial.stream()

.dropWhile(f -> f.getCalorii() < 400)
.collect(toList());

14.01.2021 POO 27
 Utilizare streams

 Trunchiere
 limit – creeaza un alt stream limitat la lungimea primita ca parametru

List<Fel> feluri = meniuSpecial.stream()

.filter(fel -> fel.getCalorii() > 400)
.limit(3)
.collect(toList());

 Ignorarea unor elemente

 skip(n) – creeaza un nou stream fara primele n elemente

List<Fel> feluri = meniuSpecial.stream()

.filter(fel -> fel.getCalorii() > 400)
.skip(3)
.collect(toList());
14.01.2021 POO 28
 Utilizare streams

 Exemplu: filtrez primele doua feluri bazate pe carne

List<Fel> feluri = meniu.stream()

.filter(fel -> fel.getTip() == Fel.Tip.CARNE)
.limit(2)
.collect(toList());

15.01.2021 POO 29
 Utilizare streams

 Map
 aplicarea unei functii fiecarui element al stream-ului

List<String> numeFeluri = meniu.stream()

.map(Fel::getNume)
.collect(toList());

List<String> cuvinte = Arrays.asList(“streams”, “in”, “java”);

List<Integer> lungCuvinte = cuvinte.stream()
.map(String::length)
.collect(toList());

15.01.2021 POO 30