Lambda-výrazy. Pecinovský

Transkript

1 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 1 z 82 Lambda-výrazy Pecinovský rudolf@pecinovsky.cz

2 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 2 z 82 Obsah 1. Terminologie 2. Funkční interfejsy a lambda výrazy 3. Nová koncepce konstrukce interface 4. Datový typ java.util.optional<t> 5. Datové proudy 6. KONEC

3 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 3 z Terminologie Obsah 1.1 Rozhraní Interfejs 1.2 Přetížení zakrytí přebití předefinování Přetížení metody method overloading Zakrytí metody method hiding Přebití metody method overriding Časná a pozdní vazba early and late binding VMT Předefinování metody method redefining Přepsání metody method rewriting

4 1.1 Rozhraní Interfejs Rozhraní Vlastnost entity programu určující, co okolní program o dané entitě ví a jak s ní může komunikovat Rozhraní mí dvě složky: Signatura označuje tu jeho část, kterou může zkontrolovat překladač Kontrakt označuje část, o jejíž dodržení se musí postarat programátor Interfejs Programová konstrukce umožňující definovat rozhraní bez implementace Počeštěný (a jazykovými slovníky povolený) tvar používám proto, abych mohl termín v textu skloňovat Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 4 z 82

5 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 5 z Přetížení zakrytí přebití předefinování Přetížení metody method overloading Několik metod má stejný název a liší se pouze v počtu a/nebo typu svých parametrů Zakrytí metody method hiding Potomek definuje metodou se stejnou signaturou jako rodič, avšak rodičovská metoda zůstává nadále dostupná Přebití metody method overriding Potomek definuje vlastní verzi zděděné virtuální metody; tato metoda musí mít signaturu kompatibilní s přebitou metodou Předefinování metody method redefining Dochází ke změně kódu metody prostřednictvím nástrojů pro instrumentaci kódu Přepsání metody method rewriting Dochází ke změně kódu metody v důsledku refaktorace či oprav chybného kódu

6 1.2.1 Přetížení metody method overloading Několik metod má stejný název a liší se pouze v počtu a/nebo typu svých parametrů Nestačí, pokud se liší pouze v názvu parametrů, metody se musejí opravdu lišit v počtu svých parametrů a/nebo se musejí lišit typy alespoň v jedné dvojici vzájemně si odpovídajících parametrů Příklad: public void setposition(int x, int y); public void setposition(position position) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 6 z 82

7 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 7 z Zakrytí metody method hiding Potomek definuje metodou se stejnou signaturou jako rodič, avšak rodičovská metoda zůstává nadále dostupná Zakrytí se v Javě uplatní pouze u statických metod K zakryté rodičovské metodě se dostanu vhodnou kvalifikací Statická metoda nesmí zakrýt instanční metodu Příklad: public class Mother { public static void hiding() { System.out.println("Definovaná v Mother, zakrytá v Daughter"); public class Daughter extends Mother{ public static void hiding() { System.out.println("Definovaná v Daughter, zakrývající tu v Mother");

8 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 8 z Přebití metody method overriding Potomek definuje vlastní verzi zděděné virtuální metody; tato metoda musí mít signaturu kompatibilní s přebitou metodou Přebití se uplatní pouze u virtuálních metod Virtuální metoda je taková, jejíž implementace a začlenění do programu umožňuje její přebití Chování je stejné jako v kartách: metoda potomka přebije rodičovskou, takže tato se neuplatní, i když nadále existuje nezměněná Typy parametrů a návratové hodnoty mohou být stejné, ale nemusí; protože proměnná předka akceptuje odkaz na instanci potomka Typ parametrů musí akceptovat proměnné typu deklarovaného rodičem => typ parametru v přebíjející metodě může být rodičem typu odpovídajícího parametru v metodě přebité Typ návratové hodnoty být přiřaditelný do proměnné typu deklarovaného rodičem => typ návratové hodnoty přebíjející metody může být potomkem typu návratové hodnoty přebíjené metody Příklad: public String tostring() { return "Přebíjí metodu zděděnou od předka.";

9 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 9 z Časná a pozdní vazba early and late binding V souvislosti s přebíjením metod se často hovoří o časné a pozdní vazbě (early and late binding) Časná vazba označuje situaci, kdy překladač již při překladu ví, která metoda bude volána a může je proto v kódu volat přímo, anebo dokonce nahradit volání metody kopií jejího těla (in-lined code) Pozdní vazba označuje stav, kdy se to, která konkrétní metoda bude volána, zjistí až za běhu, a proto je nutné použít nepřímé metody volání Pozdní vazba se většinou realizuje prostřednictvím tabulky virtuálních metod (VMT virtual method table) VMT obsahuje adresy na kódy virtuálních metod Překladač o každé metodě ví, kolikátá je ve VMT Dceřiné typy přebírají VMT svého rodiče a mohu do něj přidat další položky Přebije-li dceřiná metoda rodičovskou, překladač zařídí, aby příslušný odkaz ve VMT odkazoval na dceřinou metodu

10 1.2.5 VMT Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 10 z 82

11 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 11 z Předefinování metody method redefining Dochází ke změně kódu metody prostřednictvím nástrojů pro instrumentaci kódu Tyto nástroje mohou změnit definici třídy (a tím i jejich metod) v průběhu zavádění třídy instancí třídy ClassLoader Prostřednictvím instrumentace se může teoreticky změnit signatura metody, nicméně v zájmu konzistence s ostatním kódem se tak nečiní, protože jinak by bylo třeba upravit i další kód Někdy se tímto termínem označuje změna definice metody v důsledku nějaké refaktorace

12 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 12 z Přepsání metody method rewriting Dochází ke změně kódu metody v důsledku refaktorace či oprav chybného kódu Po přepsání metody je, a rozdíl od předchozích operací, nutný nový překlad dané třídy. Při přepsání metody se může změnit její signatura Refaktorace kódu = úpravy, které upravují strukturu kódu, ale nemění jeho funkci Přejmenování třídy / atributu /metody Záměna pořadí parametrů metody Náhrada parametru soukromé metody atributem a naopak Vyjmutí skupiny příkazů do samostatné metody, která je pak z původní metody volána Převedení posloupnosti rozhodování na aplikaci vzoru Stav

13 2. Funkční interfejsy a lambda výrazy Obsah 2.1 Návrhový vzor Příkaz (Command) 2.2 Funkční interfejs Funkční interfejsy v balíčku java.util.function Důležité funkční interfejsy z jiných balíčků 2.3 Lambda-výrazy Syntaktická pravidla Použití v programu Lambda-výraz jako parametr teorie Lambda-výraz jako parametr příklad Rozšířená verze příkladu Metody jako hodnoty lambda-výrazů Příklad Metoda volající zadanou metodu Použití metody report( ) Využití konstruktoru jako tovární metody 2.4 Další syntaktická a sémantická pravidla Použití this a super v lambda-výrazech Lambda-výrazy anonymní třídy Lambda-výrazy uzávěry Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 13 z 82

14 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 14 z Návrhový vzor Příkaz (Command) Inverzní vzor ke vzoru Služebník: Máme objekt, který něco umí, ale nezná nějakou klíčovou akci tu mu předáme prostřednictvím objektu předaného v parametru Program zabalí akci do objektu, který předá metodě v parametru /** Světlo zadaný počet krát na zabliká. */ public void blink(int times, int period) { class MyRunnable implements Runnable { public void run() { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable action = new MyRunnable(); //Metoda repeat očekává v prvním parametru počet opakování //a v druhém parametru parametru akci, která se má opakovat new Repeater().repeat(times, action);

15 2.2 Funkční interfejs Dosud jediná vyčleněná kategorie: značkovací interfejsy (tagging/marking interfaces) Nedeklarují žádnou abstraktní metodu (deklarují pouze kontrakt), a proto nevyžadují implementaci nějaké metody Nová kategorie: funkční interfejsy (function interfaces) Deklarují právě jednu abstraktní metodu (tj. vyžadující implementaci právě jedné metody); Neabstraktních metod může mít kolik chce Pokud interfejs přebije kontrakt některé z metod zděděných od třídy Object, není to deklarace abstraktní metody Nepočítají se ani statické metody a metody s implicitní implementací Ve standardní knihovně byla takovýchto interfejsů řada, ale doposud byly především jednoúčelové (Comparable, Runnable,...) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 15 z 82

16 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 16 z Rozhodneme-li se definovat funkční interfejs, je vhodné anotovat daný typ Anotace není povinná, ale poskytuje překladači informaci, že má u daného datového typu zkontrolovat, že se opravdu jedná o interfejs s jedinou abstraktní metodou Ve standardní knihovně je 231 funkčních interfejsů, přičemž pouze 57 z nich je takto anotováno Program javadoc při vytváření dokumentace nezávisle na anotaci zjistí, zda právě vytváří dokumentaci funkčního interfejsu, a pokud ano, doplní do záhlaví dokumentační stránky zprávu Functional Interface: This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

17 2.2.2 Funkční interfejsy v balíčku java.util.function Nová verze knihovny přináší speciální balíček java.util.function, definující celou řadu obecných funkčních interfejsů V balíčku je 43 interfejsů rozdělených do několika skupin: Metody interfejsů ze skupiny Consumer jsou čistí konzumenti. Zpracují své parametry, ale nic nevrací. Metody interfejsů ze skupiny Supplier jsou naopak čistí producenti. Nepotřebují žádné parametry a vracejí hodnotu zadaného typu. Metody interfejsů ze skupiny Function jsou klasické funkce: zpracují svůj parametr a vrátí funkční hodnotu. Metody interfejsů ze skupiny UnaryOperator představují unární operátory. Jsou definovány jako potomci funkcí, jejichž návratová hodnota je stejného typu jako jejich parametr. Metody interfejsů ze skupiny BinaryOperator představují binární operátory. Jsou také definovány jako potomci funkcí, tentokrát funkcí se dvěma parametry přičemž typy obou parametrů i funkční hodnoty jsou shodné. Metody interfejsů ze skupiny Predicate slouží k získání logické hodnoty odvozené z hodnoty jejich parametru. Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 17 z 82

18 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 18 z 82 //Producenti žádné parametry, jen vracejí hodnotu Supplier<T> T get() BooleanSupplier boolean getasboolean() DoubleSupplier double getasdouble() IntSupplier int getasint() LongSupplier long getaslong() //Konzumenti Zpracují parametry, nic nevracejí //Jednoparametričtí Consumer<T> void accept(t value) DoubleConsumer void accept(double value) IntConsumer void accept(int value) LongConsumer void accept(long value) //Dvouparametričtí BiConsumer<T, U> void accept(t t, U value) ObjDoubleConsumer void accept(t t, double value) ObjIntConsumer void accept(t t, int value) ObjLongConsumer void accept(t t, long value)

19 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 19 z 82 //Funkce zpracují parametr (parametry) a vrátí hodnotu //Jednoparametrické vracející objekt Function <T, R> R apply(t value) DoubleFunction < R> R apply(double value) IntFunction < R> R apply(int value) LongFunction < R> R apply(long value) // Jednoparametrické vracející hodnotu primitivního typu ToIntFunction <T> int applyasint (T value) ToDoubleFunction<T> double applyasdouble(t value) ToLongFunction <T> long applyaslong (T value) DoubleToIntFunction int applyasint (double value) DoubleToLongFunction long applyaslong (double value) IntToDoubleFunction double applyasdouble(int value) IntToLongFunction long applyaslong (int value) LongToDoubleFunction double applyasdouble(long value) LongToIntFunction int applyasint (long value) //Dvouparametrické BiFunction <T, U, R> R apply (T t, U u) ToDoubleBiFunction<T, U, R> double applyasdouble(t t, U u) ToIntBiFunction <T, U, R> int applyasint (T t, U u) ToLongBiFunction <T, U, R> long applyaslong (T t, U u)

20 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 20 z 82 //Predikáty metody (funkce) vracející logickou hodnotu Predicate<T> boolean test(t value) DoublePredicate boolean test(double value) IntPredicate boolean test(int value) LongPredicate boolean test(long value) BiPredicate<T, U> boolean test(t t, U u) //Unární operátory UnaryOperator<T> T apply (T operand) DoubleUnaryOperator double applyasdouble(double operand) IntUnaryOperator int applyasint (int operand) LongUnaryOperator long applyaslong (long operand) //Binární operátory BinaryOperator<T> T apply (T left, T right) DoubleBinaryOperator double applyasdouble(double left, double right) IntBinaryOperator int applyasint (int left, int right) LongBinaryOperator long applyaslong (long left, long right)

21 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 21 z Důležité funkční interfejsy z jiných balíčků //Balíček: java.awt.event ActionListener void actionperformed(actionevent e) //Balíček: java.io Closeable FileFilter FilenameFilter Flushable void close() boolean accept(file pathname) boolean accept(file dir, String name) void flush() //Balíček: java.lang AutoCloseable void close() Comparable<T> int compareto(t o) Iterable<T> Iterator<T> iterator() Runnable void run() //Balíček: java.util. Comparator<T> Observer boolean equals(object obj) void update(observable o, Object arg)

22 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 22 z Lambda-výrazy Lambda-výrazy představují způsob, jak definovat jako objekt nějakou část kódu, kterou bychom v jiné části programu rádi použili Lambda-výraz můžeme uložit do proměnné funkčního typu a předávat metodám jako hodnotu parametru tohoto typu Překladač definuje lambda-výraz jako instanci funkčního interfejsu, jehož metoda má odpovídající parametry a vrací hodnotu odpovídajícího typu (příslušný převod překladač zařídí) Lambda výraz se definuje některým z následujících způsobů: (parametry) -> { příkazy //Obecný tvar parametr -> { příkazy //Jediný parametr (parametry) -> výraz //Tělo tvoří pouze vyhodnocovaný výraz parametr -> výraz //Jediný parametr + pouze výraz

23 2.3.1 Syntaktická pravidla Je-li vlevo jediný parametr, nemusí se dávat do kulatých závorek; není-li žádný nebo je-li jich více, závorky jsou potřeba Dokáže-li si překladač odvodit typ parametru, nemusí se uvádět Pokud se vpravo pouze vyhodnocuje nějaký výraz, jehož hodnota se vrací, nemusí se dávat do složených závorek. Z lokálních proměnných lze v lambda výrazu použít pouze tzv. efektivní lokální konstanty metody, v níž je výraz definován, tj.: Klasické konstanty (tj. proměnné definované s modifikátorem final) Proměnné, které by překladač jako konstanty akceptoval (jakmile je jim přiřazena nějaká hodnota, už se nemění). Pro atributy žádná omezení na konstanty neplatí Potřebujeme-li v lambda-výrazu používat lokální proměnnou hodnotu, musím ji zabalit do konstantního mutable objektu Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 23 z 82

24 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 24 z Použití v programu Světlo schopné nezávislého blikání použitelné např. pro blinkr auta použijeme návrhový vzor Služebník (původní verze s anonymní třídou) /*************************************************************************** * Světlo zadaný počet krát na zabliká, tj. * na zadaný počet milisekund se rozsvítí a na stejnou dobu zhasne. * Akce probíhá na pozadí, takže nijak neovlivňuje běh okolního programu. * times Kolikrát světlo blikne period Perioda blikání zadaná v milisekundách */ public void blink(int times, int period) { Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; new Repeater().repeat(times, action);

25 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 25 z Lambda-výraz jako parametr teorie Předchozí program ale není zcela funkční, protože blikající světlo neumí zjistit, jestli stále bliká, anebo již doblikalo Problém můžeme vyřešit tak, že opětovně použijeme návrhový vzor posluchač a přihlásíme se u opakovače jako čekatelé na ukončení opakování Přihlašujeme se tak, že jako další parametr metody spouštějící opakované blikání, zadáme metodu, která se má spustit po skončení opakování

26 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 26 z Lambda-výraz jako parametr příklad Definujeme světlo, které umí požadovaný počet krát zablikat Chceme-li je použít jako ukazatel směru auta, nemůžeme použít cyklus, protože by při blikání auto zastavilo Potřebujeme spustit blikání v samostatném vlákně, aby činnost tohoto kódu neovlivňovala činnost zbytku programu Využijeme návrhový vzor služebník: instance třídy Repeater umějí zadaný počet krát provést zadanou akci předanou v parametru /** Atribut, v němž budeme uchovávat instanci služebníka. */ private Repeater repeater = null; /** * Zjistí, jestli dané světlo právě bliká. */ public boolean isblinking() { return repeater!= null;

27 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 27 z 82 Lambda-výraz jako parametr pokračování /** * Požadovaný poček krát světlem blikne nezávisle na činnosti zbytku programu, * přičemž po ukončení blikání zavolá zadanou metodu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period, Runnable finished) { assert isblinking() : "Blikání bylo spuštěno před ukončením předchozího"; repeater = new Repeater(); Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable blinkingfinished = () -> { repeater = null; finished.run(); ; repeater.repeat(times, action, blinkingfinished);

28 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 28 z Rozšířená verze předchozího příkladu Přidáváme možnost definice zavírací akce private Repeater repeater = null; //** Zjistí, jestli dané světlo právě bliká. */ public boolean isblinking() { return repeater!= null; /** Ukončí blikání a zapomene odkaz na opakovač. */ public void stopblinking() { assert (repeater!= null) : "Pokus o ukončení neexistujícího blikání"; repeater.stop(); repeater = null; /**Požadovaný poček krát světlem blikne nezávisle na činnosti zbytku programu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period) { blink(times, period, () -> {);

29 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 29 z 82 /**Požadovaný poček krát světlem blikne nezávisla na činnosti zbytku programu, * Přičemž po ukončení blikání zavolá zadanou metodu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period, Runnable finished) { assert isblinking() : "Blikání bylo spuštěno před ukončením předchozího"; repeater = new Repeater(); Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable blinkingfinished = () -> { repeater = null; finished.run(); ; repeater.repeat(times, action, blinkingfinished);

30 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 30 z Metody jako hodnoty lambda-výrazů Jako hodnotu lambda-výrazu lze definovat i existující metodu: Cls ::mtd inst::mtd Cls ::new //printmtd = IO::inform; //printmtd = System.out::println; //factmtd = MyClass::new; Stačí název metody, protože doplnění signatury o typy parametrů vyřeší překladač podle aktuálního kontextu Instanční metoda kvalifikovaná svojí instancí má stejný počet parametrů jako v deklaraci, táž metoda kvalifikovaná třídou své instance má o jeden parametr více počátečním parametrem je její instance = this Speciality: int[]::new označuje jednoparametrický konstruktor, jehož parametrem je délka zkonstruovaného pole; je to ekvivalent lambda-výrazu x > int[x]

31 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 31 z Metoda volající zadanou metodu //Kód ve třídě test\cz.pecinovsky.en_cz.uoa2_j8.aha.lambdademo /*************************************************************************** * Metoda má na starosti provedení zadané akce * spolu s oznámením jejího nastartování a ukončení. * <T> Typ parametru konzumenta description Popis druhu demonstrovaného způsobu definice metody definition Textová podoba definice metody konzumenta consumer Popsaným způsobem definovaný konzument argument Argument konzumenta */ private static <T> void report(string description, String definition, Consumer<T> consumer, T argument) { IO.inform(description + "\n\nbudeme volat metodu definovanou:\n\n" + definition); consumer.accept(argument); IO.inform("Ukončena metoda definovaná:\n\n" + definition);

32 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 32 z Použití metody report( ) //Kód ve třídě public void testconsumers() { String da; //Popis demonstrované akce String dm; //Stringová podoba definice metody Consumer<String> cs; //Konzument textových řetězců Consumer<IPaintable> cp; //Konzument zobrazitelných objektů da = "Přiřazení statické metody lambda-výrazem"; cs = (s) -> IO.inform(s); //Metoda třídy IO dm = "(s) -> IO.inform(s)"; report(da, dm, cs, dm); da = "Přímé přiřazení statické metody"; cs = IO::inform; dm = "IO::inform"; report(da, dm, cs, dm);

33 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 33 z 82 da = "Přiřazení obecné metody instance lambda-výrazem"; cs = (s) -> System.out.println(s); //Metoda instance System.out dm = "(s) -> System.out.println(s)"; report(da, dm, cs, dm); da = "Přímé přiřazení metody konkrétní instance"; cs = System.out::println; dm = "System.out::println"; report(da, dm, cs, dm); CanvasManager CM = CanvasManager.getInstance(); da = "Přiřazení metody konkrétní instance lambda-výrazem"; cp = (p) -> p.show(); dm = "(p) -> p.show()"; report(da, dm, cp, new Rectangle()); da = "Přímé přiřazení metody instance, která vystupuje v roli parametru"; cp = IPaintable::show; dm = "IPaintable::show"; report(da, dm, cp, new Ellipse());

34 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 34 z Světlo s volitelnou žárovkou private <T extends IChangeable & IColorable> Light changeshape(light light, Supplier<T> shapemaker) { Position position = light.getposition(); Size size = light.getsize(); NamedColor color = light.getcolor(); Light result = new Light(position.x, position.y, size.width, color, shapemaker); return public void testbulbshape() { CM.removeAll(); lightxy = changeshape(lightxy, Rectangle::new); lightxyc = changeshape(lightxyc, Triangle::new); lightxys = changeshape(lightxys, () -> new Triangle(0, 0, 1, 1, Direction8.SOUTH_WEST)); CM.add(lightXY, lightxyc, lightxys, lightxysc);

35 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 35 z Využití konstruktoru jako tovární metody Světlo musí být schopno vytvářet své kopie máme dvě možnosti: Budeme chtít, aby tovární metoda vytvářila kopírovatelnou žárovku Využijeme toho, že máme tovární metodu, a použijeme ji při vytváření kopie Zvolíme-li druhou variantu (je jednodušší), vznikne však problém s typem ukládaného objektu (továrny) Překladač neakceptuje deklaraci private final Supplier<T extends IChangeable & IMonocolor> bulbfactory; Akceptuje však žolíkovou variantu: private Supplier<?> bulbfactory; Žolíková varianta sice zkomplikuje zadávání továrního objektu konstruktoru v těle metody copy(), ale to se dá vyřešit přetypováním na surový typ + potlačením vypisování varovných zpráv o vypnutí kontroly typových parametrů v těle této metody

36 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 36 z 82 public Light(int x, int y, int size, NamedColor color) { this(x, y, size, color, Ellipse::new); Pokračování 1/2 public <TC extends IChangeable & IColorable> //Kombinobaný typový parametr Light(int x, int y, int size, NamedColor color, Supplier<TC> bulbfactory) //V parametru obdržíme tovární metodu { TC bulb = bulbfactory.get(); this.color = color; this.bulbfactory = bulbfactory; this.changeablebulb = bulb; this.monocolorbulb = bulb; changeablebulb.setposition(x, y); changeablebulb.setsize(size, size); monocolorbulb.setcolor(color);

37 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 37 z 82 /** Tovární objekt na výrobu žárovek. */ private final public Light copy() { Position position = changeablebulb.getposition(); Light copy = new Light(position.x, position.y, changeablebulb.getsize().width, color, (Supplier)bulbFactory); //Je třeba přetypovat na surový typ return copy; Pokračování 2/2

38 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 38 z Další syntaktická a sémantická pravidla Použití this a super v lambda-výrazech Lambda-výrazy anonymní třídy Lambda-výrazy uzávěry

39 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 39 z Použití this a super v lambda-výrazech Proměnná this použitá v lambda-výrazu se odkazuje na stejnojmenný skrytý parametr instanční metody, v níž je lambda-výraz definován Atribut super použitá v lambda-výrazu se odkazuje na stejnojmenný skrytý atribut instance, v jejíž metodě je lambda-výraz definován V lambda-výrazech definovaných ve vnitřních třídách se tak můžete odvolat na this a super příslušné vnější třídy odpovídající kvalifikací např.: EnclosingClass.this::method nebo EnclosingClass.super::method => lambda-výraz se nemůže odkázat na svůj this ani super

40 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 40 z Lambda-výrazy anonymní třídy Lambda-výrazy je vhodné použít v situacích, v nichž jsme dříve používali anonymní třídy a naopak, instance anonymních tříd lze použít místo lambda-výrazů; přesto to není totéž Na rozdíl od jiných jazyků Java nezavádí speciální typ funkcí (např.: (String, String) int)); místo toho umožňuje uložit lambda-výraz do proměnné, jejímž typem je nějaký funkční interfejs Přetypování na instanci funkčního interfejsu je také to jediné, co můžeme s lambda-výrazem udělat Lambda-výraz nelze uložit do proměnné typu Object, protože třída Object není funkční interfejs; můžeme jej ale uložit po přetypování Object o = (Object)(x -> x+1);

41 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 41 z Lambda-výrazy uzávěry Lambda-výraz má tři komponenty: Parametry Blok kódu Volné proměnné (free variables), což jsou použité lokální proměnné okolního kódu Dvojice [Blok kódu, Volné proměnné] bývá označována jako uzávěr => lambda-výrazy v Javě fungují jako uzávěry

42 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 42 z Nová koncepce konstrukce interface Obsah 3.1 Interfejs a implementace Jednoduchý diamantový problém Složitější diamantový problém Náhled přes konstanty Ukázka implicitní implementace 3.2 Speciální situace a omezení 3.3 Důsledky pro návrh architektury Použití ve standardní knihovně Ukázka použití u funkčních interfejsů 3.4 Statické metody Důsledky pro návrh architektury

43 3.1 Interfejs a implementace Java zavedla konstrukci interface jako programovou reprezentaci rozhraní Jeden z účelů byl obejití problémů při používání násobného dědění Problémy s násobnými rodiči vznikají zejména v souvislosti s násobným děděním implementace Budeme-li dědit pouze rozhraní, tj. pouze sliby, problémy v podstatě odpadají Navíc se ukázalo, že zavedením této konstrukce se otevírá celá řada nových možností v návrhu architektury Autoři některých jazyků následně ukázali, že hlavní příčinou tzv. diamantového problému je v podstatě pouze násobné dědění dat => zakážeme-li dědění dat, problémy nebudou Java proto ve verzi 8 umožňuje v definicích interfejsů uvádět i implicitní implementace metod Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 43 z 82

44 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 44 z Jednoduchý diamantový problém Při násobném dědění od společného předka dvou rodičů je třeba určit, jestli se data tohoto předka budou dědit jednou nebo dvakrát

45 3.1.2 Složitější diamantový problém Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 45 z 82

46 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 46 z Náhled přes konstanty Java umožňuje definovat v interfejsu statické konstanty Tyto konstanty nepředstavují konkrétní uložená data, jsou to především názvy, za něž se dosazují konkrétní hodnoty S nástupem lambda-výrazů lze do těchto konstant přiřazovat i kód Vzhledem k tomu, že metoda je pouze jinak zapsaný konstantní lambda-výraz, je jenom logické, že v Javě 8 lze v interfejsu definovat i metody Instanční metody s definovaným tělem se v Javě označují modifikátorem default, třídní metody se stejně jako ve třídách označují modifikátorem static Implicitní verze metod nesmí přebíjet žádnou metodu předka

47 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 47 z Ukázka implicitní implementace Definujeme metody, které by asi všichni definovali stejně public interface IMovable extends IPaintable { public Position getposition(); public void setposition(int x, int y); public default void setposition(position position) { setposition(position.x, position.y);

48 3.2 Speciální situace a omezení Objeví-li se ve stromu dědičnosti více metod se stejnou signaturou, platí následující pravidla: 1. Třída vždy vyhrává. Definuje-li rodičovská třída metodu se stejnou signaturou, jakou má implicitně definovaná metoda implementovaného interfejsu, metoda interfejsu je ignorována 2. Definují-li dva implementované interfejsy metody se shodnou signaturou, musí implementující třída vyřešit konflikt tím, že definuje vlastní verzi této metody, která přebije verze zděděné od implementovaných interfejsů, a to nezávisle na tom, jestli některá z nich (či obě) má implicitní definici. (Jinými slovy: třída se chová stejně jako před Javou 8.) Z předchozího vyplývá, že nemá smysl, aby interfejs definoval implicitní verze metod zděděných od Object, a proto tyto metody ani přebít nesmí Interfejs však může přebít implicitní metodu svého předka Interfejs nyní může obsahovat metodu main a vystupovat tak v roli hlavní třídy aplikace Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 48 z 82

49 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 49 z Důsledky pro návrh architektury Při používání klasicky navrženého interfejsu jsme museli tento interfejs velmi pečlivě navrhnout, protože jakékoliv další úpravy publikovaného interfejsu jsou zakázané Při povolení implicitních implementací deklarovaných metod můžeme dodatečně rozšiřovat funkcionalitu tříd implementujících dané interfejsy, aniž bychom museli měnit jejich kód Zavedení interfejsů s implicitní implementací nahrazuje v některých případech použití některých návrhových vzorů V řadě případů umožňuje obejít návrhový vzor Adapter (např. při návrhu posluchačů v java.awt) V dalších případech umožňuje se obejít bez použití návrhového vzoru Návštěvník (Visitor)

50 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 50 z Použití ve standardní knihovně Převážná většina interfejsů používá implicitní implementaci, v mnohých je implementovaných metod víc než těch abstraktních public interface Iterable<T> { Iterator<T> iterator(); default void foreach(consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); default Spliterator<T> spliterator() { return Spliterators.spliteratorUnknownSize(iterator(), 0);

51 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 51 z Ukázka použití u funkčních public interface BiFunction<T, U, R> { //Povinná abstraktní metoda R apply(t t, U u); //Metoda s implicitní definicí rozšiřující funkcionalitu definovaného typu //Parametrem je funkce, akceptující jako parametr návratový typ //abstraktní metody definovaného funkčního typu default <V> BiFunction<T, U, V> andthen(function<? super R,? extends V> after) { Objects.requireNonNull(after); return (T t, U u) -> after.apply(apply(t, u));

52 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 52 z Statické metody Java 8 dovoluje v interfejsu definovat statické public interface BinaryOperator<T> extends BiFunction<T,T,T> { //Vrátí operátor vracející komparátorem určenou menší ze zadaných hodnot public static <T> BinaryOperator<T> minby(comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) <= 0? a : b; //Vrátí operátor vracející komparátorem určenou větší ze zadaných hodnot public static <T> BinaryOperator<T> maxby(comparator<? super T> comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) >= 0? a : b;

53 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 53 z public interface Function<T, R> { R apply(t t); default <V> Function<V, R> compose(function<? super V,? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); default <V> Function<T, V> andthen(function<? super R,? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); static <T> Function<T, T> identity() { return t -> t;

54 3.4.1 Důsledky pro návrh architektury Možnost definovat statické metody v interfejsech osvobozuje od nutnosti definovat knihovní třídy pro skupiny tříd implementujících daný interfejs Např. řadu metod třídy Collections by bylo možno definovat jako statické metody interfejsu Collection Mnohé z knihovních metod by navíc bylo lze definovat jako instanční (např. shuffle(list), sort(list) apod.) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 54 z 82

55 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 55 z Datový typ java.util.optional<t> Obsah 4.1 Základní princip 4.2 Ekvivalenty jednoduchých operací 4.3 Získání prvotní hodnoty 4.4 Definované metody

56 4.1 Základní princip Velmi často pracujeme s proměnnými, jejichž hodnotou může být prázdný odkaz null; kód pak bývá prokládán neustálými testy na nullovost proměnné Některé jazyky řeší tento problém zavedením speciálních operátorů Groovy safe navigation operator (Elvis operator)?. (x?. y) == ((x == null)? null : x.y) Java nezavádí nový operátor, ale místo toho rozšiřuje knihovnu o generický datový typ Optional<T> Výhodou je, že takovýto typ bylo možno dodefinovat i ve starších verzích, takže pokud někdo používal něco obdobného, nebude muset měnit zvyky Další výhodou je to, že takto můžeme pro takto definované objekty definovat celou řadu pomocných služebních metod a k nim i několik továrních metod Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 56 z 82

57 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 57 z Ekvivalenty jednoduchých operací Použití hodnoty Optional<T> optional = something; optional.get().method(); je ekvivalentní klasickému T object = something. object.method() Jediným rozdílem je, že v typu vyhozené výjimky v prvním případě bude vyhozena NoSuchElementException, v druhém NullPointerException Opatrné použití hodnoty if (optional.ispresent()) { optional.get().method(); je pouze komplikovanější variantou klasického if (object!= null) { object.method();

58 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 58 z Získání prvotní hodnoty public static <T> Optional<T> empty() Získání prázdné hodnoty public static <T> Optional<T> of(t value) Získání instance obalující zadanou nenullovou hodnotu; je-li parametr null, vyhodí NullPointerException public static <T> Optional<T> ofnullable(t value) Získání instance obalující zadanou hodnotu; je-li parametr null, vrátí Optional<T>.empty()

59 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 59 z Definované metody Podmíněné volání metody public void ifpresent(consumer<? super T> consumer) optional.ifpresent(consumer); je ekvivalentní klasickému if (value!= null) { consumer.accept(value); Filtrování hodnoty public Optional<T> filter(predicate<? super T> predicate) optional = optional.filter(predicate); je ekvivalentní klasickému optional = (optional.ispresent)? (predicate(optional.get())? optional : Optional<T>.empty() : optional;

60 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 60 z 82 Mapování hodnoty na hodnotu public <U> Optional<U> map(function<? super T,? extends U> mapper) newoptional = optional.map(mapper); je ekvivalentní klasickému newoptional = optional.ispresent()? Optional<U>.ofNullable(mapper.apply(optional.get())) : Optional.empty(); Oproti filtru se zde vyrábí nová instance pomocí empty() Zplošťující mapování na hodnotu (aby nevznikl Optional<Optional<T>> public<u>optional<u> flatmap(function<? super T,Optional<U>> mapper) newoptional = optional.flatmap(mapper); je ekvivalentní klasickému newoptional = optional.ispresent()? Objects<U>.requireNonNull(mapper.apply(optional.get())) : Optional.empty(); Metoda mapper(optional<t>) musí vrátit nenullový Optional<U>

61 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 61 z 82 Přiřazení implicitní hodnoty v případě nullovosti odkazu public T orelse(t other) value = optional.orelse(other); je ekvivalentní klasickému value = optional.ispresent()? optional.get() : other; //neboli value = (ovalue!= null)? ovalue : other; Přiřazení spočtené hodnoty v případě nullovosti odkazu public T orelseget(supplier<? extends T> other) value = optional.orelseget(other); je ekvivalentní klasickému value = optional.ispresent()? optional.get() : other.get(); //neboli value = (ovalue!= null)? ovalue : other.get();

62 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 62 z Rozšířená verze předchozího příkladu Umožníme zastavení zastaveného blikání private Optional<Repeater> repeater = Optional.empty(); //** Zjistí, jestli dané světlo právě bliká. */ public boolean isblinking() { return repeater!= null; /** Ukončí blikání a zapomene odkaz na opakovač. */ public void stopblinking() { Optional<Repeater> assert (repeater!= null) : "Pokus o ukončení neexistujícího blikání"; repeater.stop(); repeater = null; /**Požadovaný poček krát světlem blikne nezávisle na činnosti zbytku programu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period) { blink(times, period, () -> {);

63 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 63 z 82 /**Požadovaný poček krát světlem blikne nezávisla na činnosti zbytku programu, * Přičemž po ukončení blikání zavolá zadanou metodu. * Nula krát znamená pořád, dokud nezavoláme stopblinking(). */ public void blink(int times, int period, Runnable finished) { assert isblinking() : "Blikání bylo spuštěno před ukončením předchozího"; repeater = new Repeater(); Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); ; Runnable blinkingfinished = () -> { repeater = null; finished.run(); ; repeater.repeat(times, action, blinkingfinished);

64 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 64 z Datovody Obsah 5.1 Seznámení Motivace Obecná charakteristika Terminologie Změna používaných iterátorů Analogie s výrobní linkou Odchylky od kolekcí a polí Typy operací s daty v proudu: Vztah operací k proudům 5.2 Operace s daty v proudu Ukázka Filtrování obsahu proudu Řazení objektů v proudu Konverze prvků v proudu 5.3 Možnosti získání proudu Tovární metody pro generování proudů

65 5.1 Seznámení Motivace Klasický postup: Opakovaně prováděj: požádej kontejner o další uloženou instance, zjisti, jestli patří mezi ty, které je třeba zpracovat, pokud ano tak instanci požadovaným způsobem zpracuj Nevýhody: Zbytečně se opakuje podobný kód V programu zpracovává jedna položka po druhé Trend: posilovat deklarativní přístup k programování Snaha moci vysvětlit co se má dělat a nechat na knihovně jak to udělá Umožníme tím specialistům navrhujícím knihovny optimalizovat řešení např. pro intenzivní využití paralelismu Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 65 z 82

66 5.1.2 Obecná charakteristika Knihovny kolekcí a polí jsou staré a těžko modifikovatelné => Snaha použít jiné přístupy známé z funkcionálního programování Ve FP jsou proudy chápány jako univerzální posloupnosti postupně zpřístupňovaných dat Java 8: Proud je klíčová abstrakce pro zpracování skupin dat umožňující specifikovat, co se má s daty dělat, a abstrahovat od toho, jak se to bude dělat Většina metod proudů čte data proudu a vrací proud obsahující data příslušné (před)zpracovaná Ukázka sečti váhy červených udělátek v kolekci widgets int sum = widgets.stream().filter(b -> b.getcolor() == RED).mapToInt(b -> b.getweight()).sum(); Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 66 z 82

67 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 67 z Terminologie V OOP jsou pod termínem proud často chápány objekty zprostředkovávající přenos dat od zdroje k cíli Datové proudy jsou pak většinou spojovány přenosem dat od zdroje k cíli, přičemž zdrojem či cílem může být program, soubor, datovod (pipe), oblast paměti, objekt, Ve standardní knihovně Javy jsou takto pojímané proudy definovány jako potomci abstraktních tříd InputStream, OutputStream, Reader a Writer Funkcionální programování však tento termín používá pro potenciálně nekonečné seznamy, které však data neuchovávají, ale pouze o nich ví. Program definuje, jaká data se do proudu zařadí, resp. jak proud ona data získá Nezávisle na tom se definuje, co se těmito daty bude dělat Proudy jsou ve své přirozenosti funkcionální, takže nemění data umístěná v proudu každé dato je za života proudu navštíveno jen jednou Většina operací je implementována jako odložené (lazy)

68 5.1.4 Změna používaných iterátorů Při práci s klasickými poli a kolekcemi se používají především externí (sekvenční) iterátory Program požádá kolekci o iterátor, který pak v cyklu žádá o další instanci, s níž provede požadovanou operaci Proud se chová jako objekt využívající interní (dávkové) iterátory provádějící s iterovanými objekty operace definované lambda-výrazy Výhody: Z programu zmizí pomocný kód, který měl na starosti řízení iterací, (tj. popis jak to dělat) a zpřehlední se tak popis akcí, které budou popisovat, co se zpracovávanými objekty udělat Objeví-li se v budoucnu nějaké propracovanější techniky paralelizace prováděných činností, není třeba upravovat část programu řešící aplikační logiku, ale stačí pouze vylepšit knihovnu proudů a tím se automaticky zefektivní zpracování programů, které tyto proudy využívají Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 68 z 82

69 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 69 z Analogie s výrobní linkou Na počátku je vstup V případě výrobního pásu je to sklad dílů, nebo nějak zabezpečený přísun vstupních surovin od dodavatele V případě proudu to bude zdroj dat většinou nějaký zdrojový kontejner, zdrojem ale může být i generátor, který vytváří data na požádání Pracoviště Podél výrobního pásu jsou připravená pracoviště, na nichž zaškolení dělníci provádějí jednotlivé operace V případě proudu nahradíme dělníky metodami (přesněji lambda výrazy), které s přišedším objektem provedou požadovanou operaci a vypustí jej do dalšího proudu, kde pokračuje k dalšímu pracovišti Výsledky Na konci výrobního pásu vypadne hotový výrobek Na konci série operací s daty v proudu obdržíme (doufejme ) požadovaný výsledek

70 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 70 z Odchylky od kolekcí a polí Proudy si neblokují žádnou paměť pro zpracovávaná data; data od někud přitékají, pracoviště je zpracuje a pošle dál Ve většině případů zpracování neovlivňuje zdrojová data Důležité při hromadném zpracování dat několika procesory, protože pak se můžeme na jejich hodnoty spolehnout Naplánované průběžné operace se chovají obdobně jako dělníci u pásu: Nehrnou se do skladu (kontejneru), aby v něm data zpracovaly, ale: 1. Počkají si, až k nim zpracovávaný objekt po vstupním proudu přiteče 2. Přišedší objekt zpracují 3. Zpracovaný objekt vloží do výstupního proudu a vrátí odkaz na tento proud

71 5.1.7 Typy operací s daty v proudu: Filtrace Např. při procházení souborů na disku mne zajímají jen ty s danou příponou Mapování (konverze) Z přišedšího objektu mne zajímá jen hodnota jednoho atributu do výstupního proudu odchází ona Řazení Pro další zpracování potřebuji mít data definovaným způsobem seřazena Souhrny (reduction, folding) Na přitékajících datech mne zajímá pouze nějaká souhrnná informace průměr, součet, Sdružování (mutable reduction) Zpracovaná data vkládám do nějakého kontejneru (kolekce, pole, ) Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 71 z 82

72 5.1.8 Vztah operací k proudům Vrácený proud nemusí být shodný se vstupním Když má operace např. zjistit počet znaků v řetězci, je vstupním proudem proud textových řetězců (stringů) a výstupním proudem proud celých čísel V případě potřeby může mít výstupní proud jinak uspořádaná data než proud vstupní Operace nejsou nijak ovlivněny tím, zda je vstup dat konečný (klasický kontejner), nebo nekonečný Data prostě přitékají a co přiteče, to se zpracuje, a čeká se na další Operace nejsou svázány s konkrétním proudem; program může postupně vytvářet různé proudy, na jejichž data pošle danou sadu operací Jednou může být zdrojem dat kolekce, jindy generátor apod. Operace pouze vědí, že data přijdou, ony je mají zpracovat a někam poslat Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 72 z 82

73 5.2 Operace s daty v proudu Průběžné (intermediate) Převezmou objekt, zpracují jej a pošlou dále po proudu, případně je předají do jiného proudu Vracejí proud, takže je lze jednoduše zřetězit Nemusejí vždy vracet svůj proud, ale mohou vracet i jiný => nelze obecně zavolat průběžnou metodu, aniž bychom si zapamatovali proud, který nám vrátí a jehož metodu pak musíme v dalším kroku oslovit Koncové (terminal) Zakončují činnost proudu a předávají výsledek okolnímu programu Výstupní hodnotou může být kolekce, objekt, ale také nic Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 73 z 82

74 Copyright Rudolf Pecinovský, Soubor: 09_Lambda_vyrazy.doc, verze , uloženo ne :36 74 z Ukázka /*************************************************************************** * Zabezpečí, aby každé světlo na zhaslo, bliklo a opět se rozsvítilo. * To, jestli budou světla pracovat postupně nebo všechna najednou, * záleží na typu proudu. */ private void streamblink(stream<light> stream, String text) { //Akci, kterou budu chtít zadat vícekrát, si připravím a uložím Consumer<Light> pause = (o)->io.pause(500); //Zapamatuje si proud vrácený poslední průběžnou operací stream = stream //Diktuji operace, které se budou v proudu postupně provádět.peek(light::switchoff).peek(pause).peek(light::blink).peek(pause).peek(light::switchon); //Zatím se nic nedělo, dít se začne až při provádění terminální akce long count = stream.count(); IO.inform(text + "\n\nblikalo: " + count);