• Autori: Florian-Luis Micu , Sorina-Anamaria Buf , Ștefan Cocioran
• Data publicării: 15.12.2025
• Data ultimei modificări: 15.12.2025

Scopul acestui laborator este prezentarea unei noi paradigme, concret paradigma funcțională. Aceasta vine ca un superset peste OOP în limbajul Java, tocmai pentru a facilita diverse procese.

Aspectele urmărite sunt:

• ce este programarea funcțională și cum este integrată în Java.
• definirea și folosirea lambda expressions.
• recunoașterea și utilizarea interfețelor funcționale.
• lucrul cu Stream API pentru procesarea colecțiilor.
• diferențe dintre stilul imperativ și stilul funcțional de programare.
• identificarea avantajelor, limitărilor și capcanelor ale abordării funcționale în Java.

Java a fost conceput inițial ca un limbaj strict orientat pe obiecte, în care:

• logica este exprimată prin clase,
• comportamentul este definit prin metode,
• execuția este descrisă pas cu pas (stil imperativ, ca în C).

Cu toate acestea, pe măsură ce aplicațiile au devenit:

• mai mari,
• mai concurente,
• mai orientate pe procesarea colecțiilor de date,

a apărut nevoia unui stil de programare:

• mai declarativ,
• mai ușor de paralelizat,
• mai puțin dependent de o stare mutabilă.

Începând cu Java 8, limbajul introduce:

• lambda expressions
• interfețe funcționale
• Stream API

care permit scrierea de cod într-un stil funcțional, fără a abandona modelul OOP.

În stilul imperativ, programatorul descrie exact pașii de execuție:

List<Integer> result = new ArrayList<>();
 
for (Integer x : numbers) {
    if (x % 2 == 0) {
        result.add(x * 2);
    }
}

Caracteristici:

• control explicit al fluxului (for, if)
• variabile temporare
• stare mutabilă
• risc crescut de erori (ex: uităm să inițializăm lista)

int a = 0;
System.out.prtinln(a); // printează 0
a = 2;
System.out.prtinln(a); // acum printează 2, deci este mutable

În stilul funcțional, descriem ce transformări vrem să aplicăm, nu pașii exacți:

List<Integer> result =
    numbers.stream()
           .filter(x -> x % 2 == 0)
           .map(x -> x * 2)
           .toList();

Ce se întâmplă aici?

• stream() creează o vedere funcțională asupra colecției
• filter selectează elementele dorite
• map transformă fiecare element
• toList() colectează rezultatul final

O interfață funcțională este o interfață care definește exact o metodă abstractă.

@FunctionalInterface
public interface Operation {
    int apply(int a, int b);
}

Această restricție permite compilatorului să știe ce metodă trebuie implementată de o expresie lambda, deoarece există doar o metodă de implementat.

Avem următorul cod care definește cum putem folosi interfața funcțională Operation definită mai sus:

Operation add = new Operation() {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
};
 
System.out.println(add.apply(2, 3));

O expresie lambda este o implementare inline a metodei unei interfețe funcționale.

Operation add = (a, b) -> a + b;
 
System.out.println(add.apply(2, 3));

Este echivalent logic cu exemplul anterior.

O expresie lambda poate fi definită în două feluri:

(parametri) -> expresie
(parametri) -> { bloc de cod }

Practic, vom avea mereu:

1. paranteze în care specificăm numărul de parametrii,
2. operatorul săgeată (→) care specifică trecerea la corpul metodei,
3. o expresie simplă sau un bloc de cod mai complex împrejmuit de acolade.

Exemple:

// o metodă cu un parametru care întoarce dublul lui
x -> x * 2   
 
// o metodă cu doi parametrii care întoarce suma lor                      
(x, y) -> x + y
 
// o metodă fără parametrii care întoarce "void"                      
() -> System.out.println("Hello")
 
// o metodă fără parametrii, mai complexă, care întoarce "void"
() -> {
    System.out.println("Hello");
    System.out.println("World");
}
 
// o metodă cu un parametru, mai complexă, care întoarce un număr
x -> {    
    int y = x + 10;
 
    System.out.println("x is: " + x + " y is: " + y);
 
    return (x * 2) / y;
}

int x = 10; // effectively final
 
Runnable r = () -> {
    System.out.println(x);
};

Interfețele funcționale ne ajută practic să simulăm pointeri la funcții ca în limbajul C.

Totuși, pentru că Java este un limbaj OOP, are o restricție care împiedică folosirea sintaxei din C.

Tip de prim ordin (first-class) este un element care poate:

1. să fie stocat într-o variabilă
2. să fie transmis ca parametru
3. să fie returnat dintr-o funcție
4. să existe independent de o clasă

Exemple de tipuri first-class în Java:

int x = 10;
String s = "hello";
Object o = new Object();

Însă, Java nu permite:

int add(int a, int b) { return a + b; }
 
// NU este permis
var f = add;

Nu poți scrie:

return add;

Nu poți spune:

void process(Function f) { }

În Java apar aceste restricții pentru că:

• metodele aparțin claselor
• nu există funcții independente
• metodele nu sunt valori

Expresiile lambda funcționează doar cu interfețe funcționale pentru că compilatorul știe ce metodă implementează, deoarece există doar o metodă de definit.

Interfața funcțională este un contract, iar lambda-ul este implementarea acestui contract.

Deci când scriem:

Operation add = (a, b) -> a + b;
 
add.apply(2, 3);

Practic avem următorii pași:

1. se definește funcția generală în interfața Operation care definește o singură metodă abstractă.
2. dezvoltatorul definește metoda generală, iar compilatorul știe că această metodă suprascrie singura metodă abstractă din interfață.
3. rezultatul expresiei lambda este o instanță a interfeței funcționale care este stocată într-o referință care are tipul interfeței funcționale.

Într-o lambda:

• this se referă la clasa exterioară
• nu există un this propriu

În schimb, într-o clasă anonimă:

• this se referă la instanța anonimă

Java oferă, în pachetul java.util.function, un set de interfețe funcționale standard, gândite special pentru a fi folosite împreună cu lambda expressions și Stream API.

Aceste interfețe:

• elimină necesitatea definirii propriilor interfețe simple,
• standardizează tipurile de operații funcționale,
• sunt intens folosite intern de Stream API.

Predicate<T> modelează o condiție booleană aplicată asupra unui obiect de tip T.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

• Primește: un obiect de tip T
• Returnează: boolean
• Scop: testare/filtrare

Predicate<Integer> isEven = x -> x % 2 == 0;

Utilizare:

isEven.test(10); // true

Function<T, R> modelează o transformare dintr-un tip T într-un tip R.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

• Primește: T
• Returnează: R
• Scop: transformare

Function<String, Integer> length = s -> s.length();

Utilizare:

System.out.println(length.apply("ana")); // 3

Consumer<T> modelează o operație care primește un obiect T, nu returnează nimic, dar produce de obicei un side-effect.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

• Primește: T
• Returnează: nimic (void)
• Scop: efect secundar (side effects)

Consumer<String> printer = s -> System.out.println(s);

Utilizare:

printer.accept("Hello World"); // Hello World

Supplier<T> produce o valoare fără a primi nimic.

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

• Primește: nimic
• Returnează: T
• Scop: generare valori

Supplier<Double> random = () -> Math.random();

Utilizare:

System.out.println(random.get()); // un număr aleator

Un method reference este o formă prescurtată a unei expresii lambda, atunci când lambda-ul apelează direct o metodă existentă fără logică suplimentară.

Exemple de echivalență:

x -> System.out.println(x)
System.out::println

x -> x.length()
String::length

() -> new ArrayList<>()
ArrayList::new

1. Static method

Integer::parseInt

2. Metodă a unei instanțe (pe un obiect)

System.out::println

3. Metodă a unei instanțe (pe un tip)

String::toUpperCase

4. Constructor

ArrayList::new

Un Stream reprezintă o vedere funcțională asupra unei surse de date (de obicei o colecție), care permite aplicarea unei succesiuni de transformări într-un mod declarativ.

Un stream:

• nu este o colecție
• nu stochează date
• nu modifică sursa
• descrie ce se întâmplă cu datele, nu cum se întâmplă

Exemplu:

numbers.stream()
       .filter(x -> x % 2 == 0)
       .map(x -> x * 2)
       .toList();

Explicație:

• numbers este sursa
• stream() creează un stream
• filter și map sunt transformări
• toList() produce rezultatul final

Este esențial să nu confundăm aceste concepte pentru a nu avea erori în cod.

Exemplu greșit:

Stream<Integer> s = numbers.stream();
s.forEach(el -> System.out.println(el));
s.forEach(el -> System.out.println(el)); // EROARE

Un stream nu poate fi reutilizat.

Operațiile pe stream-uri sunt lazy, adică ele nu se execută imediat.

numbers.stream()
       .filter(x -> {
           System.out.println("filter: " + x);
           return x % 2 == 0;
       });

Codul de mai sus nu afișează nimic, deoarece nu există o operație terminală.

Execuția începe doar când apare o operație terminală (cum ar fi count()):

numbers.stream()
       .filter(x -> x % 2 == 0)
       .count();

Operațiile intermediare:

• returnează un Stream
• sunt lazy
• pot fi înlănțuite

Exemple:

• filter - Păstrează doar elementele care respectă o condiție.
• map - Transformă fiecare element într-un alt element.
• flatMap - Transformă fiecare element într-un stream și apoi aplatizează rezultatul.
• sorted - Sortează elementele stream-ului, natural sau cu un comparator.
• distinct - Elimină elementele duplicate (pe baza equals()).
• limit - Păstrează doar primele N elemente din stream.
• peek - Permite observarea elementelor fără a le modifica (debug/logging).

Exemplu:

numbers.stream()
       .filter(x -> x > 0)
       .map(x -> x * 2);

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
 
List<Integer> even =
    numbers.stream()
           .filter(x -> x % 2 == 0)
           .toList();
 
System.out.println(even);

[2, 4, 6]

List<String> names = List.of("Ana", "Ion", "Maria");
 
List<Integer> lengths =
    names.stream()
         .map(name -> name.length())
         .toList();
 
System.out.println(lengths);

[3, 3, 5]

List<List<String>> lists = List.of(
    List.of("a", "b"),
    List.of("c", "d")
);
 
List<String> flat =
    lists.stream()
         .flatMap(list -> list.stream())
         .toList();
 
System.out.println(flat);

[a, b, c, d]

lists.stream()
     .map(List::stream)
     .toList();

List<Integer> numbers = List.of(5, 1, 4, 2, 3);
 
List<Integer> sorted =
    numbers.stream()
           .sorted()
           .toList();

[1, 2, 3, 4, 5]

List<Integer> numbers = List.of(1, 2, 2, 3, 3, 3);
 
List<Integer> unique =
    numbers.stream()
           .distinct()
           .toList();

[1, 2, 3]

List<Integer> numbers = List.of(10, 20, 30, 40, 50);
 
List<Integer> firstThree =
    numbers.stream()
           .limit(3)
           .toList();
 
System.out.println(firstThree);

[10, 20, 30]

List<Integer> numbers = List.of(1, 2, 3, 4);
 
List<Integer> result =
    numbers.stream()
           .peek(x -> System.out.println("Before: " + x))
           .map(x -> x * 2)
           .peek(x -> System.out.println("After: " + x))
           .toList();
 
System.out.println("Result: " + result);

Before: 1
After: 2
Before: 2
After: 4
Before: 3
After: 6
Before: 4
After: 8
Result: [2, 4, 6, 8]

Operațiile terminale:

• returnează un rezultat concret
• declanșează execuția întregului pipeline
• consumă stream-ul

Exemple:

• forEach - Aplică o acțiune fiecărui element din stream.
• toList - Colectează elementele într-o Listă imutabilă (Java 16+).
• collect - Colectează elementele într-o structură folosind un Collector.
• reduce - Combină toate elementele într-o singură valoare.
• count - Returnează numărul de elemente din stream.
• findFirst - Returnează primul element din stream (dacă există).
• anyMatch - Verifică dacă există cel puțin un element care respectă o condiție.

Exemplu:

long count = numbers.stream()
                    .filter(x -> x > 0)
                    .count();

List<String> names = List.of("Ana", "Ion", "Maria");
 
names.stream()
     .forEach(name -> System.out.println(name));

Ana
Ion
Maria

List<Integer> numbers = List.of(1, 2, 3, 4);
 
List<Integer> doubled =
    numbers.stream()
           .map(x -> x * 2)
           .toList();
 
System.out.println(doubled);

[2, 4, 6, 8]

List<String> names = List.of("Ana", "Ion", "Ana");
 
Set<String> uniqueNames =
    names.stream()
         .collect(Collectors.toSet());
 
System.out.println(uniqueNames);

[Ana, Ion]

List<Integer> numbers = List.of(1, 2, 3, 4);
 
int sum =
    numbers.stream()
           .reduce(0, (a, b) -> a + b);
 
System.out.println(sum);

10

List<String> words = List.of("a", "b", "c", "d");
 
long count =
    words.stream()
         .count();
 
System.out.println(count);

4

List<Integer> numbers = List.of(10, 20, 30);
 
Optional<Integer> first =
    numbers.stream()
           .findFirst();
 
System.out.println(first);

Optional[10]

List<Integer> numbers = List.of(1, 3, 5, 6);
 
boolean hasEven =
    numbers.stream()
           .anyMatch(x -> x % 2 == 0);
 
System.out.println(hasEven);

true

Stream API este construit direct peste interfețele funcționale din java.util.function, astfel că anumite metode din stream-uri acceptă doar anumite interfețe funcționale:

Exemplu:

numbers.stream()
       .filter(x -> x % 2 == 0)       // Predicate<Integer>
       .map(x -> x * 2)               // Function<Integer, Integer>
       .forEach(System.out::println); // Consumer<Integer>

Stream-urile NU ar trebui să modifice stare externă, din motivele prezentate mai sus.

Exemplu greșit:

int sum = 0;
 
numbers.stream()
       .forEach(x -> sum += x); // side effect

Exemplu corect:

int sum = numbers.stream().mapToInt(x -> x).sum();

Stream-urile nu funcționează pe etape separate. Fiecare element trece prin toate etapele separat de execuția celorlalte elemente.

Exemplu:

numbers.stream()
       .filter(x -> {
           System.out.println("filter " + x);
           return x % 2 == 0;
       })
       .map(x -> {
           System.out.println("map " + x);
           return x * 2;
       })
       .forEach(System.out::println);

Output:

filter 1
filter 2
map 2
4
filter 3
filter 4
map 4
8

Un parallel stream împarte procesarea pe mai multe thread-uri, folosind ForkJoinPool.

numbers.parallelStream()
       .map(x -> x * 2)
       .toList();

sau:

numbers.parallelStream()
       .map(x -> x * 2)
       .toList();

Pot fi utile când:

• avem seturi mari de date
• operațiile sunt costisitoare
• funcțiile sunt pure (fără side effects)

Nu este recomandat să folosim parallel streams când:

• modificăm starea externă
• folosim forEach cu side effects
• ordinea contează
• setul de date este mic

Exemplu problematic:

int sum = 0;
 
numbers.parallelStream()
       .forEach(x -> sum += x); // RACE CONDITION

Exemplu corect:

int sum =
    numbers.parallelStream()
           .mapToInt(x -> x)
           .sum();

Vi se dă scheletul pentru o aplicație ce simulează o situație mai mult sau mai puțin fictivă. Mai multe firme cooperează cu o bancă pentru a oferi salariul și beneficiile salariațiilor lor. Firmele au mai mulți salariați și mai multe proiecte în istoric. Este posibil ca unii salariați să fi schimbat firma la care lucrează, dar li se pastrează în istoricul personal proiectele la care au lucrat. Un salariat poate avea mai multe conturi bancare făcute prin firma la care lucrează.

Aveți de implementat:

• TODO-urile din clasele Business, Bank si Employee - întoarceți tipurile corespunzatoare de date, dar asigurați-vă că sunt imutabile (hint: Collections.unmodifiable*)
• metodele statice din clasele BankReport și BusinessReport

Pentru testare sunt folosite 10 teste, fiecare dintre acesta reprezentand 10 puncte.

Dezambiguizare:

• Customer = Employee of the Business
• Business = a client of the Bank
• Customers of the Bank = all the Employees that work for the Businesses that are clients of the Bank

• Stream API - Oracle Docs
• Java Functional Programming - Baeldung