03/28/2024

Cum să înveți Java Stream API [+5 Resources]

Un flux în Java este o secvență de elemente pe care pot fi efectuate operații secvențiale sau paralele.

Poate exista un număr „n” de operații intermediare și, în sfârșit, o operație terminală, după care rezultatul este returnat.

Ce este un flux?

Fluxurile pot fi gestionate de Stream API, care a fost introdus în Java 8.

Imaginează-ți Stream ca o conductă de producție în care unele bunuri trebuie să fie fabricate, sortate și apoi ambalate pentru expediere. În Java, acele bunuri sunt obiecte sau colecții de obiecte, operațiunile sunt fabricarea, sortarea și ambalarea, iar conducta este fluxul.

Componentele unui flux sunt:

  • O intrare inițială
  • Operații intermediare
  • Operarea terminalului
  • Rezultat final

Să explorăm câteva caracteristici ale unui flux în Java:

  • Stream nu este o structură de date în memorie; mai degrabă, este o secvență de tablouri, obiecte sau colecții de obiecte care sunt operate prin anumite metode.
  • Fluxurile sunt de natură declarativă, adică specificați ce să faceți, dar nu cum să o faceți.
  • Pot fi consumate o singură dată, deoarece nu sunt depozitate nicăieri.
  • Stream nu modifică structura originală a datelor; nu decurge din ea decât o nouă structură.
  • Returnează rezultatul final derivat din metoda finală în conductă.

API-ul Stream vs. Procesarea colecțiilor

O colecție este o structură de date în memorie care stochează și procesează date. Colecțiile oferă structuri de date, cum ar fi Set, Map, List etc., pentru a stoca date. Pe de altă parte, un flux este o modalitate de a transfera eficient date după procesarea lor printr-o conductă.

Iată un exemplu de colecție ArrayList:-

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(0, 3);
        System.out.println(list);
    }
}

Output: 
[3]

După cum puteți vedea în exemplul de mai sus, puteți crea o colecție ArrayList, puteți stoca date în ea și apoi puteți opera pe acele date folosind diferite metode.

  Cum să măriți și să micșorați un Chromebook (5 moduri)

Folosind un flux, puteți opera pe o structură de date existentă și puteți returna o nouă valoare modificată. Mai jos este un exemplu de creare a unei colecții ArrayList și filtrare folosind un flux.

import java.util.ArrayList;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();

        for (int i = 0; i < 20; i++) {
            list.add(i+1);
        }

        System.out.println(list);

        Stream<Integer> filtered = list.stream().filter(num -> num > 10);
        filtered.forEach(num -> System.out.println(num + " "));
    }
}

#Output

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 

În exemplul de mai sus, un flux este creat folosind lista existentă, iar lista este iterată pentru a filtra valori mai mari de 10. Observați că fluxul nu stochează nimic, lista este doar iterată și rezultatul este tipărit. Dacă încercați să imprimați fluxul, veți obține o referință la flux în loc de valori.

Se lucrează la Java Stream API

API-ul Java Stream preia o colecție sursă de elemente sau o secvență de elemente și apoi efectuează operații asupra acestora pentru a obține un rezultat final. Un flux este doar o conductă prin care trece o secvență de elemente și se transformă într-un fel.

Un flux poate fi creat din diverse surse, inclusiv:

  • O colecție, cum ar fi o listă sau un set.
  • O matrice.
  • Din fișiere și căile acestora folosind un buffer.

Există două tipuri de operații efectuate într-un flux: –

  • Operațiuni intermediare
  • Operațiuni terminale

Operațiuni intermediare vs

Fiecare operație intermediară returnează un nou flux intern care transformă intrarea folosind metoda specificată. Nimic nu este de fapt traversat; În schimb, este transmis la următorul flux. Numai la operațiunea terminalului fluxul este parcurs pentru a obține rezultatul dorit.

De exemplu, aveți o listă de 10 numere pe care doriți să le filtrați și apoi să le mapați la ceva. Nu fiecare element al listei va fi parcurs imediat pentru a obține rezultatul filtrat și a-l mapa pe altceva. În schimb, elementele individuale vor fi verificate și, dacă îndeplinesc condiția, vor fi mapate. Fluxuri noi pentru fiecare element.

Operația hărții va fi efectuată pe elemente individuale care satisfac filtrul și nu întreaga listă. Și în momentul operațiunii terminale, acestea sunt parcurse și combinate într-un singur rezultat.

  Cum se scanează și se remediază vulnerabilitatea Log4j?

După efectuarea operațiunii de terminal, fluxul este consumat și nu mai poate fi utilizat în continuare. Trebuie să creați un nou flux pentru a efectua din nou aceleași operațiuni.

Sursa: The Bored Dev

Având o înțelegere la nivel de suprafață a modului în care funcționează fluxurile, haideți să trecem la detaliile implementării fluxurilor în Java.

#1. Un flux gol

Creați un flux gol utilizând metoda goală a API-ului Stream.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream emptyStream = Stream.empty();
        System.out.println(emptyStream.count());
    }
}

Output:
0

Aici, dacă imprimați numărul de elemente din acest flux, obțineți 0 ca rezultat, deoarece este un flux gol fără elemente. Fluxurile goale sunt destul de utile pentru a evita excepțiile pointerului nul.

#2. Transmiteți în flux din colecții

Colecții precum Listă și Set expun o metodă stream() care vă permite să creați un flux dintr-o colecție. Fluxul creat poate fi apoi traversat pentru a obține rezultatul final.

ArrayList<Integer> list = new ArrayList();

for (int i = 0; i < 20; i++) {
    list.add(i+1);
}

System.out.println(list);

Stream<Integer> filtered = list.stream().filter(num -> num > 10);
filtered.forEach(num -> System.out.println(num + " "));

#Output

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 

#3. Transmiteți în flux din Arrays

Metoda Arrays.stream() este folosită pentru a crea un flux dintr-o matrice.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] stringArray = new String[]{"this", "is", "tipstrick.ro"};
        Arrays.stream(stringArray).forEach(item -> System.out.print(item + " "));
    }
}

#Output

this is tipstrick.ro 

De asemenea, puteți specifica indexul de început și de sfârșit al elementelor pentru a crea un flux. Indicele de început este inclusiv, în timp ce indicele de final este exclusiv.

String[] stringArray = new String[]{"this", "is", "tipstrick.ro"};
Arrays.stream(stringArray, 1, 3).forEach(item -> System.out.print(item + " "));

Output:
is tipstrick.ro

#4. Găsirea numerelor minime și maxime folosind Streams

Accesarea numărului maxim și minim al unei colecții sau al unui tablou se poate face folosind Comparatoare în Java. Metodele min() și max() acceptă un comparator și returnează un obiect Opțional.

Un obiect Opțional este un obiect container care poate sau nu conține o valoare non-nulă. Dacă conține o valoare non-nulă, apelarea metodei get() pe aceasta va returna valoarea.

import java.util.Arrays;
import java.util.Optional;

public class MinMax {
    public static void main(String[] args) {
        Integer[] numbers = new Integer[]{21, 82, 41, 9, 62, 3, 11};

        Optional<Integer> maxValue = Arrays.stream(numbers).max(Integer::compare);
        System.out.println(maxValue.get());

        Optional<Integer> minValue = Arrays.stream(numbers).min(Integer::compare);
        System.out.println(minValue.get());
    }
}

#Output
82
3

Resurse de învățare

Acum că aveți o înțelegere de bază a fluxurilor în Java, iată 5 resurse pentru a vă familiariza bine cu Java 8:

  Un ghid aprofundat despre tipurile de noduri Blockchain

#1. Java 8 în acțiune

Această carte este un ghid care prezintă noi caracteristici ale Java 8, inclusiv fluxuri, lambda și programare în stil funcțional. Testele și întrebările de verificare a cunoștințelor fac, de asemenea, parte din carte, care vă vor ajuta să recuperați ceea ce ați învățat.

Puteți obține această carte în format broșat, precum și în format audiobook pe Amazon.

#2. Java 8 Lambdas: programare funcțională pentru mase

Această carte este concepută special pentru a-i învăța pe dezvoltatorii de bază Java SE cum adăugarea expresiilor Lambda afectează limbajul Java. Include explicații fluide, exerciții de cod și exemple pentru a stăpâni expresiile lambda Java 8.

Este disponibil în format paperback și ediție Kindle pe Amazon.

#3. Java SE 8 pentru cei cu adevărat nerăbdători

Dacă sunteți un dezvoltator Java SE cu experiență, această carte vă va ghida prin îmbunătățirile aduse în Java SE 8, API-ul de flux, adăugarea de expresii lambda, îmbunătățiri ale programării concurente în Java și unele caracteristici Java 7 pe care majoritatea oamenilor le folosesc. nu stiu despre.

Este disponibil doar în format broșat pe Amazon.

#4. Aflați programarea funcțională Java cu Lambda și fluxuri

Acest curs de la Udemy explorează elementele fundamentale ale programării funcționale în Java 8 și 9. Expresiile Lambda, Referințele de Metodă, Fluxurile și Interfețele funcționale sunt conceptele pe care se concentrează acest curs.

Include, de asemenea, o grămadă de puzzle-uri și exerciții Java legate de programarea funcțională.

#5. Biblioteca de clase Java

Biblioteca de clasă Java face parte din specializarea Core Java oferită de Coursera. Vă va învăța cum să scrieți cod sigur utilizând Java Generics, să înțelegeți biblioteca de clase care constă din peste 4000 de clase, cum să lucrați cu fișiere și cum să gestionați erorile de rulare. Cu toate acestea, există câteva condiții prealabile pentru a urma acest curs:

  • Introducere în Java
  • Introducere în programarea orientată pe obiecte cu Java
  • Ierarhii orientate pe obiecte în Java

Cuvinte finale

API-ul Java Stream și introducerea funcțiilor Lambda în Java 8 au simplificat și îmbunătățit o mulțime de lucruri în Java, cum ar fi iterația paralelă, interfețele funcționale, mai puțin cod etc.

Cu toate acestea, fluxurile au unele limitări; cea mai mare limitare a lor este că pot fi consumate o singură dată. Dacă sunteți un dezvoltator Java, resursele menționate mai sus vă pot ajuta să înțelegeți aceste subiecte mult mai detaliat, așa că asigurați-vă că le verificați.

Poate doriți să aflați și despre gestionarea excepțiilor în Java.

x