Operațiile de reducere

Operațiile de reducere reprezintă operații terminale care returnează o valoare rezultată din procesarea fluxului de date. În Stream API există o serie de operații de reducere.

Metoda count()

Metoda count() returnează numărul de elemente din fluxul de date:

import java.util.stream.Stream;
import java.util.Optional;
import java.util.*;
public class Program {

   public static void main(String[] args) {

       ArrayList<String> names = new ArrayList<String>();
       names.addAll(Arrays.asList(new String[]{"Tom", "Sam", "Bob", "Alice"}));
       System.out.println(names.stream().count());  // 4

       // numărul de elemente cu lungime de cel mult 3 caractere
       System.out.println(names.stream().filter(n -> n.length() <= 3).count());  // 3
   }
}

Metoda findFirst și findAny

Metoda findFirst() extrage primul element din flux, iar findAny() extrage un obiect aleator din flux (adesea tot primul):

ArrayList<String> names = new ArrayList<String>();
names.addAll(Arrays.asList(new String[]{"Tom", "Sam", "Bob", "Alice"}));

Optional<String> first = names.stream().findFirst();
System.out.println(first.get());    // Tom

Optional<String> any = names.stream().findAny();
System.out.println(any.get());    // Tom

Metodele allMatch, anyMatch și noneMatch

Aceste metode returnează o valoare booleană (true sau false) și verifică dacă toate, unele sau niciunul dintre elementele fluxului respectă o anumită condiție:

boolean allMatch(Predicate<? super T> predicate) - returnează true dacă toate elementele fluxului îndeplinesc condiția
boolean anyMatch(Predicate<? super T> predicate) - returnează true dacă cel puțin un element îndeplinește condiția
boolean noneMatch(Predicate<? super T> predicate) - returnează true dacă niciun element nu îndeplinește condiția

Exemplu de utilizare:

import java.util.stream.Stream;
import java.util.Optional;
import java.util.ArrayList;
import java.util.Arrays;
public class Program {

   public static void main(String[] args) {

       ArrayList<String> names = new ArrayList<String>();
       names.addAll(Arrays.asList(new String[]{"Tom", "Sam", "Bob", "Alice"}));

       // există un șir cu lungime mai mare de 3 caractere?
       boolean any = names.stream().anyMatch(s -> s.length() > 3);
       System.out.println(any);    // true

       // toate șirurile au lungimea de 3 caractere?
       boolean all = names.stream().allMatch(s -> s.length() == 3);
       System.out.println(all);    // false

       // nu există șirul "Bill" în flux?
       boolean none = names.stream().noneMatch(s -> s.equals("Bill"));
       System.out.println(none);   // true
   }
}

Metodele min() și max()

Metodele min() și max() returnează valoarea minimă sau maximă din flux. Deoarece datele din flux pot reprezenta diferite tipuri (inclusiv clase complexe), metodele primesc un obiect Comparator care definește modul de comparare a obiectelor:

Optional<T> min(Comparator<? super T> comparator)
Optional<T> max(Comparator<? super T> comparator)

Ambele metode returnează un element din flux, ambalat într-un obiect Optional.

De exemplu, să găsim numărul minim și maxim într-un flux numeric:

import java.util.stream.Stream;
import java.util.Optional;
import java.util.ArrayList;
import java.util.Arrays;
public class Program {

   public static void main(String[] args) {

       ArrayList<Integer> numbers = new ArrayList<Integer>();
       numbers.addAll(Arrays.asList(new Integer[]{1,2,3,4,5,6,7,8,9}));

       Optional<Integer> min = numbers.stream().min(Integer::compare);
       Optional<Integer> max = numbers.stream().max(Integer::compare);
       System.out.println(min.get());  // 1
       System.out.println(max.get());  // 9
   }
}

Interfața Comparator este o interfață funcțională care definește o metodă compare, ce primește doi parametri de tipul obiectelor de comparat și returnează un număr. Putem folosi expresii lambda sau metode predefinite, precum Integer.compare().

Metodele min și max returnează un obiect Optional, iar pentru a obține rezultatul operației este necesar să apelăm metoda get().

Un exemplu mai complex, unde comparăm obiecte de tip Phone:

import java.util.stream.Stream;
import java.util.Optional;
import java.util.ArrayList;
import java.util.Arrays;
public class Program {

   public static void main(String[] args) {

       ArrayList<Phone> phones = new ArrayList<Phone>();
       phones.addAll(Arrays.asList(new Phone[]{
           new Phone("iPhone 8", 52000),
           new Phone("Nokia 9", 35000),
           new Phone("Samsung Galaxy S9", 48000),
           new Phone("HTC U12", 36000)
       }));

       Phone min = phones.stream().min(Phone::compare).get();
       Phone max = phones.stream().max(Phone::compare).get();
       System.out.printf("MIN Nume: %s Preț: %d \n", min.getName(), min.getPrice());
       System.out.printf("MAX Nume: %s Preț: %d \n", max.getName(), max.getPrice());
   }
}

class Phone {

   private String name;
   private int price;

   public Phone(String name, int price){
       this.name = name;
       this.price = price;
   }
   public static int compare(Phone p1, Phone p2){
       return Integer.compare(p1.getPrice(), p2.getPrice());
   }
   public String getName() { return name; }
   public int getPrice() { return price; }
}

În acest caz, găsim obiectul Phone cu prețul minim și maxim. Metoda de comparare este definită în clasa Phone, iar metoda compare este utilizată în min și max pentru compararea obiectelor.

Rezultatul în consolă:

MIN Nume: Nokia 9 Preț: 35000
MAX Nume: iPhone 8 Preț: 52000