Hogyan lehet megtanulni a Java Stream API-t [+5 Resources]

Szerző:
Tweet
Share
Share
Pin

A Java adatfolyam olyan elemek sorozata, amelyeken szekvenciális vagy párhuzamos műveletek hajthatók végre.

Lehet „n” számú köztes művelet és végül egy terminálművelet, amely után az eredményt visszaadjuk.

Mi az a Stream?

A streameket a Java 8-ban bevezetett Stream API kezelheti.

Képzelje el a Stream-et gyártási folyamatként, amelyben bizonyos árukat le kell gyártani, válogatni, majd csomagolni kell a szállításhoz. A Java-ban ezek az áruk objektumok vagy objektumgyűjtemények, a műveletek a gyártás, a válogatás és a csomagolás, a folyamat pedig az adatfolyam.

A stream összetevői a következők:

  • Egy kezdeti bemenet
  • Köztes műveletek
  • Terminál működése
  • Végeredmény

Fedezzük fel a Java adatfolyam néhány funkcióját:

  • A Stream nem egy memórián belüli adatstruktúra; inkább tömbök, objektumok vagy objektumgyűjtemények sorozata, amelyeket bizonyos módszerekkel működtetnek.
  • Az adatfolyamok deklaratív jellegűek, azaz Ön megadja, hogy mit tegyen, de azt nem, hogyan tegye.
  • Csak egyszer fogyasztható, mivel nem tárolják sehol.
  • A Stream nem módosítja az eredeti adatstruktúrát; csak új szerkezetet merít belőle.
  • A folyamatban lévő végső metódusból származó végeredményt adja vissza.

Stream API vs. gyűjtemények feldolgozása

A gyűjtemény egy memórián belüli adatstruktúra, amely adatokat tárol és dolgoz fel. A gyűjtemények olyan adatstruktúrákat biztosítanak, mint a Set, Map, List stb. az adatok tárolására. Másrészt az adatfolyam egy módja annak, hogy hatékonyan továbbítsuk az adatokat, miután azokat egy csővezetéken keresztül feldolgoztuk.

Íme egy példa egy ArrayList gyűjteményre: –

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]

Amint az a fenti példában látható, létrehozhat egy ArrayList gyűjteményt, tárolhat benne adatokat, majd különböző módszerekkel kezelheti ezeket az adatokat.

  Mi az a Google Tanterem, és kinek érdemes használnia?

Egy adatfolyam segítségével egy meglévő adatstruktúrán dolgozhat, és új módosított értéket adhat vissza. Az alábbiakban egy ArrayList gyűjtemény létrehozására és egy adatfolyam segítségével történő szűrésére mutatunk be példát.

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

A fenti példában egy adatfolyamot hozunk létre a meglévő lista felhasználásával, és a lista ismétlődik a 10-nél nagyobb értékek szűrésére. Figyelje meg, hogy az adatfolyam nem tárol semmit, a lista csak iterálódik, és az eredmény kinyomtatásra kerül. Ha megpróbálja kinyomtatni az adatfolyamot, akkor értékek helyett hivatkozást kap a folyamra.

Java Stream API-n dolgozik

A Java Stream API beveszi az elemek forrásgyűjteményét vagy az elemek sorozatát, majd műveleteket hajt végre rajtuk a végeredmény levezetéséhez. A folyam csak egy csővezeték, amelyen keresztül elemek sorozata halad át, és valamilyen módon átalakul.

Egy adatfolyam többféle forrásból hozható létre, többek között:

  • Gyűjtemény, például lista vagy készlet.
  • Egy tömb.
  • Fájlokból és elérési útjaikból puffer segítségével.

Egy adatfolyamban kétféle művelet végezhető: –

  • Köztes műveletek
  • Terminálműveletek

Köztes és terminál műveletek

Minden közbenső művelet belsőleg egy új adatfolyamot ad vissza, amely átalakítja a bemenetet a megadott metódussal. Valójában semmit sem haladnak át; Ehelyett átkerül a következő folyamba. A kívánt eredmény elérése érdekében a folyamon csak a terminál műveleténél kell áthaladni.

Például van egy 10 számból álló listája, amelyet ki szeretne szűrni, majd le szeretne képezni valamire. A lista nem minden eleme halad át azonnal, hogy megkapjuk a szűrt eredményt és leképezzük valami másra. Ehelyett az egyes elemek ellenőrzésre kerülnek, és ha megfelelnek a feltételnek, leképeződnek. Új adatfolyamok minden egyes elemhez.

  Hová mentik a Mac-ek a képernyőképeket?

A térképművelet a szűrőnek megfelelő egyes elemeken történik, és nem a teljes listán. A terminál működése során pedig bejárják és egyetlen eredménybe egyesítik őket.

A terminálművelet végrehajtása után az adatfolyam elfogy, és tovább nem használható. Ugyanezen műveletek ismételt végrehajtásához új adatfolyamot kell létrehoznia.

Forrás: The Bored Dev

Az adatfolyamok működésének felszíni megértésével ugorjunk bele a folyamok Java-ban való megvalósításának részleteibe.

#1. Egy üres adatfolyam

Hozzon létre egy üres adatfolyamot a Stream API üres metódusával.

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

Itt, ha kiírod az elemszámot ebben a folyamban, akkor 0-t kapsz kimenetként, mert ez egy üres adatfolyam, elemek nélkül. Az üres adatfolyamok nagyon hasznosak a nullmutató kivételek elkerülésében.

#2. Adatfolyam a gyűjteményekből

Az olyan gyűjtemények, mint a Listák és a Set, egy stream() metódust tesznek lehetővé, amely lehetővé teszi adatfolyam létrehozását egy gyűjteményből. A létrehozott folyamon ezután bejárható a végeredmény.

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. Streamelés az Arrays-ből

Az Arrays.stream() metódus egy tömbből való adatfolyam létrehozására szolgál.

import java.util.Arrays;

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

#Output

this is etoppc.com

Megadhatja az elemek kezdő és záró indexét is, amelyekből adatfolyamot szeretne létrehozni. A kezdőindex inkluzív, míg a végindex kizárólagos.

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

Output:
is etoppc.com

#4. Minimális és maximális számok keresése Streams segítségével

Egy gyűjtemény vagy tömb maximális és minimális számának elérése a Java Comparators használatával érhető el. A min() és max() metódusok elfogadnak egy komparátort és egy Opcionális objektumot adnak vissza.

Az opcionális objektum egy olyan tárolóobjektum, amely tartalmazhat nem nulla értéket, vagy nem. Ha nem null értéket tartalmaz, a get() metódus meghívása visszaadja az értéket.

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

Tanulási források

Most, hogy már alapszintű ismeretekkel rendelkezik a Java streamelésről, itt van 5 forrás, amelyek segítségével jól ismerkedhet a Java 8-ban:

  9 módszer a Spotify Premium örökre ingyenes beszerzésére

#1. Java 8 akcióban

Ez a könyv egy útmutató, amely bemutatja a Java 8 új funkcióit, beleértve a streameket, a lambdákat és a funkcionális stílusú programozást. Kvízek és tudásellenőrző kérdések is a könyv részét képezik, amelyek segítenek visszaszerezni a tanultakat.

Ezt a könyvet beszerezheti puhakötésű formátumban, valamint hangoskönyv formátumban az Amazonon.

#2. Java 8 lambdák: Funkcionális programozás tömegek számára

Ez a könyv kifejezetten arra készült, hogy megtanítsa a fő Java SE fejlesztőknek, hogyan hat a Lambda kifejezések hozzáadása a Java nyelvre. Könnyű magyarázatokat, kódgyakorlatokat és példákat tartalmaz a Java 8 lambda kifejezések elsajátításához.

Puhakötésű formátumban és Kindle kiadásban érhető el az Amazonon.

#3. Java SE 8 az igazán türelmetleneknek

Ha Ön tapasztalt Java SE fejlesztő, ez a könyv végigvezeti Önt a Java SE 8 fejlesztésein, a stream API-n, a lambda kifejezések hozzáadásán, a Java párhuzamos programozásának fejlesztésein és néhány Java 7 szolgáltatáson, amelyeket a legtöbb ember nem ismer. nem tudni róla.

Csak puhakötésű formátumban érhető el az Amazonon.

#4. Tanuljon Java funkcionális programozást lambdákkal és adatfolyamokkal

Udemy ezen kurzusa a funkcionális programozás alapjait tárja fel Java 8-ban és 9-ben. A lambda-kifejezések, a módszerreferenciák, az adatfolyamok és a funkcionális interfészek azok a fogalmak, amelyekre a kurzus összpontosít.

Tartalmaz még egy csomó Java-rejtvényt és a funkcionális programozáshoz kapcsolódó gyakorlatokat.

#5. Java osztálykönyvtár

A Java osztálykönyvtár a Coursera által kínált Core Java specializáció része. Megtanítja Önnek, hogyan írjon típusbiztos kódot a Java Generics segítségével, hogyan ismerje meg a több mint 4000 osztályból álló osztálykönyvtárat, hogyan kell dolgozni a fájlokkal, és hogyan kell kezelni a futásidejű hibákat. Van azonban néhány előfeltétele a tanfolyam elvégzésének:

  • Bevezetés a Java-ba
  • Bevezetés az objektum-orientált programozásba Java-val
  • Objektum-orientált hierarchiák a Java nyelven

Végső szavak

A Java Stream API és a Lambda funkciók bevezetése a Java 8-ban sok mindent leegyszerűsített és továbbfejlesztett a Java-ban, mint például a párhuzamos iteráció, a funkcionális interfészek, kevesebb kód stb.

A folyamoknak azonban vannak korlátai; legnagyobb korlátjuk, hogy csak egyszer fogyaszthatók. Ha Ön Java-fejlesztő, a fent említett források segíthetnek sokkal részletesebben megérteni ezeket a témákat, ezért feltétlenül nézze meg őket.

Érdemes tudni a Java kivételkezeléséről is.

Tweet
Share
Share
Pin