Trendy v návrhu SW architektury

Transkript

1 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 1 z 71 Trendy v návrhu SW architektury Pecinovský rudolf@pecinovsky.cz

2 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 2 z 71 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 3 z Terminologie Obsah 1.1 Rozhraní Interfejs 1.2 Přetížení zakrytí přebití předefinování

4 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 4 z 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

5 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 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ů 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ů 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

6 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 6 z 71 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á Typ parametrů a návratové hodnoty musí být přiřaditelný do typu deklarovaného rodičem, takže typ v přebíjející metodě může být potomkem typu odpovídajícího parametru (návratové hodnoty) v metodě přebité V souvislosti s přebíjením metod se často hovoří o časné a pozdní vazbě Č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í

7 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 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 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 7 z 71

8 2. Funkční interfejsy a lambda výrazy Obsah 2.1 Funkční interfejs Funkční interfejsy v balíčku java.util.function Důležité funkční interfejsy z jiných balíčků 2.2 Lambda-výrazy Syntaktická pravidla Použití v programu Lambda-výraz jako parametr Metody jako hodnoty lambda-výrazů Metoda volající zadanou metodu Použití metody report( ) Využití konstruktoru jako tovární metody 2.3 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 8 z 71

9 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 9 z Funkční interfejs Dosud jediná vyčleněná kategorie: značkovací interfejsy (tagged 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,...)

10 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 10 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.

11 2.1.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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 11 z 71

12 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 12 z 71 //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)

13 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 13 z 71 //Funkce zpracují parametr (parametry) a vrátí hodnotu //Jednoparametrikcé 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) // Jednoparametrikcé 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) //Dvouparametrikcé 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)

14 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 14 z 71 //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) //Predikáty metody 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)

15 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 15 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)

16 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 16 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

17 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 17 z 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, 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

18 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 18 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 /*************************************************************************** * 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); }

19 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 19 z 71 Doplnění kontroly, zda nespouštíme blikání světla, které již bliká private volatile Repeater repeater = null; public boolean isblinking() { return repeater!= null; } public void blink(int times, int period) { assert (! isblinking()) : //Abych mohl spustit blikání, nesmí blikat "Blikání bylo spuštěno před ukončením předchozího"; Runnable action = () -> { switchon(); IO.pause(period/2); switchoff(); IO.pause(period/2); }; new Repeater().repeat(times, action); }

20 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 20 z Lambda-výraz jako parametr Předchozí program ale není zcela funkční, protože blikající světlo ale 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í

21 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 21 z 71 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); }

22 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 22 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 okamžité situace Speciality: int[]::new označuje jednoparametrický konstruktor, jehož parametrem je délka zkonstruovaného pole; je to ekvivalent lambda-výrazu x > int[x]

23 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 23 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); }

24 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 24 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);

25 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 25 z 71 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 konkrétní instance"; cp = IPaintable::show; dm = "IPaintable::show"; report(da, dm, cp, new Ellipse());

26 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 26 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

27 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 27 z 71 public Light(int x, int y, int size, NamedColor color) { this(x, y, size, color, Ellipse::new); } 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);

28 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 28 z 71 /** 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; }

29 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 29 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

30 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 30 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

31 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 31 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

32 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 32 z Lambda-výrazy uzávěry Lambda-výraz má tři komponenty: Blok kódu Parametry 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

33 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 33 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

34 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 34 z 71

35 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 35 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

36 3.1.2 Složitější diamantový problém Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 36 z 71

37 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 37 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

38 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 38 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); }

39 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 39 z 71

40 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 40 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)

41 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 41 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); }

42 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 42 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)); }

43 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 43 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; }

44 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 44 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; }

45 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 45 z 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.)

46 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 46 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

47 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 47 z 71

48 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 48 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(); }

49 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 49 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()

50 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 50 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;

51 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 51 z 71 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>

52 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 52 z 71 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();

53 5. Datové proudy 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ů Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 53 z 71

54 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 54 z 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

55 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: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 55 z 71

56 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 56 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)

57 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 57 z 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í

58 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 58 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

59 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 59 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

60 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 60 z 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, )

61 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 61 z 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

62 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 62 z 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

63 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 63 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); }

64 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 64 z 71 //Testy výše uvedené public void setup() { lightxys = new Light( 0, 0, 100); lightxy = new Light(100, 50); lightxyc = new Light( 50, 100, NamedColor.RED); lightxysc = new Light(100, 100, 100, NamedColor.GREEN); lightsarr = new Light[] {lightxy, lightxyc, lightxys, lightxysc}; lightscol = Arrays.asList(lightsArr); public void testgroupblink() { Stream<Light> stream = Arrays.stream(lightsArr); //lightscol.stream(); streamblink(stream, "testgroupblink"); public void testgroupblinkparallel(){ Stream<Light> stream = lightscol.parallelstream(); //Arrays.stream(lightsArr).parallel(); streamblink(stream, "testgroupblinkparallel"); }

65 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 65 z 71 Pokud bychom nechtěli ukázat, že akce se spouští až při zavolání koncové metody, mohli bychom použít test ve tvaru private void streamblinkfe(stream<light> stream) { //Akci, kterou budu chtít zadat vícekrát, si připravím a uložím Runnable pause = ()->IO.pause(500); //Zapamatuje si proud vrácený poslední průběžnou operací stream.foreach((light x) -> { x.switchoff(); pause.run(); x.blink(); pause.run(); x.blink(); pause.run(); x.blink(); pause.run(); x.switchon(); }); public void testgroupblinkfe() { Stream<Light> stream = lights.stream(); streamblinkfe(stream); }

66 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 66 z Filtrování obsahu proudu Obsah proudu můžeme během práce filtrovat použitím metody Stream<T> filter(predicate<? super T> predicate) /************************************************************************** * Začlení světla do paralelního proudu, odfiltruje ta, co nejsou žlutá, * a ta zbylá (tj. ta žlutá) nechá společně zablikat. public void testyellowblink() { Stream<Light> stream = lightscol.parallelstream(); stream = stream.filter((light) -> light.getcolor().equals(namedcolor.yellow)); streamblink(stream, "testyellowblinkd"); }

67 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 67 z Řazení objektů v proudu K zadání akce přeuspořádavající daný proud slouží metody Stream<T> sorted() Stream<T> sorted(comparator<? super T> comparator) /************************************************************************** * Začlení světla do sériového proudu, seřadí je v něm podle vodorovné * souřadnice a nechá je v tomto pořadí postupně zablikat. public void testxsortedblink() { Stream<Light> stream = lights.stream(); stream = stream.sorted((first, second) -> first.getposition().x - second.getposition().x); streamblink(stream); }

68 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 68 z Konverze prvků v proudu Prvek, který do proudu nastoupil, doposud procházel jednotlivými zastávkami, dokud činnost proudu neskončila Proudy však umožňují vyměnit cestou druh prvků, s nimiž pracují prostřednictvím některé z metod: <R> Stream<R> map(function<? super T,? extends R> mapper) DoubleStream maptodouble(todoublefunction<? super T> mapper) IntStream maptoint (ToIntFunction <? super T> mapper) LongStream maptolong (ToLongFunction <? super T> mapper) public static void createanddrive(ivehiclefactory vehiclefactory, String directions, Position... positions) { Arrays.stream(positions).parallel().map(vehicleFactory::newVehicle) //Převede pozice na vozidla.peek((vehicle) -> {CM.add(vehicle);}).forEach(goInDirections(directions)); }

69 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 69 z Možnosti získání proudu Z kolekcí prostřednictvím metod stream() a parallelstream() Z polí prostřednictvím metody Arrays.stream(Object[]) Řádky souboru lze získat metodou BufferedReader.lines() Proud souborů na zadané cestě (java.nio.file.path) lze získat metodami třídy java.nio.file.files Proud náhodných čísel lze získat metodou Random.ints() Proud položek v ZIP-souboru lze získat metodou JarFile.stream() Proud částí sekvence znaků lze získat voláním statické metody Pattern.splitAsStream(java.lang.CharSequence) Proud indexů nastavených položek lze získat voláním BitSet.stream()

70 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 70 z Tovární metody pro generování proudů Třída Stream nabízí navíc metody, s jejichž pomocí lze definovat generátory proudů zadaným způsobem vytvořených objektů static <T> Stream<T> of(t... values) Vytvoří proud zadaných hodnot static <T> Stream<T> iterate(t seed, UnaryOperator<T> f) Vytvoří nekonečný seřazený proud, jehož počáteční prvek je tvořen semenem seed a následující prvky jsou vytvářeny aplikací operátoru f na předchozí prvek static <T> Stream<T> generate(supplier<t> s) Vytvoří nekonečný proud, jehož prvky jsou výsledkem volání s IntStream range(int, int) Třída IntStream umí vytvořit proud celých čísel ze zadaného intervalu

71 Copyright Rudolf Pecinovský, Soubor: PR_Funkcionalni_konstrukce_v_Jave_8.doc, verze , uloženo út :22 71 z KONEC Děkuji za pozornost Rudolf Pecinovský rudolf@pecinovsky.cz