Aplikacje w Javie wykład 13 Elementy programowania funkcyjnego

Aplikacje w Javie wykład 13 1 Elementy programowania funkcyjnego Treści prezentowane w wykładzie zostały oparte o: Barteczko, JAVA Programowanie praktyczne od podstaw, PWN, 2014 http://docs.oracle.com/javase/8/docs/ C. S. Horstmann, Java. Techniki zaawansowane, Helion, Gliwice 2017

Programowanie funkcyjne - wprowadzenie WJavie w wersji 8 wprowadzono, co prawda w ograniczonym zakresie, wsparcie dla programowania funkcyjnego. Obejmuje ono przede wszystkim lambda-wyrażenia oraz przetwarzanie strumieniowe. Zanim poznamy lambda-wyrażenia w szczegółach, możemy o nich myśleć jako o bezpośrednio podawanych fragmentach kodu, swoistych funkcjach bez nazwy, które są traktowane "jak prawdziwe obiekty", czyli np. mogą być przekazywane metodom. Dzięki zastosowaniu lambda-wyrażeń poprzedni przykład wywołania metody create() upraszczamy praktycznie do jednej linijki: List<Integer> target = create(src, n -> n < 10, n -> n*n); Tu zapis: n -> n < 10 jest lambda-wyrażeniem, które możemy traktować jako anonimową funkcję, której parametrem jest n, i która zwraca wynik wyrażenia n<10. Nie wchodząc na razie w szczegóły, można powiedzieć, że kompilator "dopasowuje" to lambda-wyrażenie do drugiego parametru (Filter<S>) metody create(...), w wyniku czego użyta tam metoda test(...) interfejsu Filter "pod spodem" uzyskuje odpowiednią implementację: boolean test(integer n) { return n < 10; Podobnie dzieje z lambda-wyrażeniem: n -> n*n pasującym do wywołania metody transform(...) interfejsu Transformer. 2

5 Programowanie funkcyjne - wprowadzenie Metoda create(...) nie do końca jest uniwersalna. Być może chcielibyśmy najpierw przetworzyć dane, a filtrować wyniki tego przetwarzania. A może filtrować, przetwarzać i znowu filtrować? Te wszystkie przypadki możemy łatwo obsłużyć za pomocą przetwarzania strumieniowego. Pokażemy teraz szczególne przypadki jego użycia, dobrze zastępujące i znacznie poszerzające funkcjonalność, stworzonej wcześniej metody create(...) i to bez konieczności definiowania jakichkolwiek własnych interfejsów. W kontekście wcześniejszych przykładowych kodów, sekwencja działań jest następująca. Od listy metodą stream() uzyskujemy tzw. strumień (inaczej zwany sekwencją), a na danych strumienia możemy wykonywać m.in. operacje przetwarzania (metoda map), filtrowania (metoda filter) oraz uzyskiwać nowe kolekcje wyników tych operacji (metoda collect). Metodzie map podajemy lambda-wyrażenie, którego wynikiem jest przetworzenie jego parametru (działa to tak jak transform() z naszego interfejsu Transformer). Metoda zwraca strumień, na którym można wykonywać dalsze operacje. Metodzie filter podajemy lambdę przekształcającą parametr w wartość boolowską (tak jak nasz filter()). Filtrowanie zwraca strumień, który pozwala wykonywać ew. dalsze operacje tylko na tych danych, dla których wynik lambdy jest true. Możemy zatem wywoływać sekwencje map-filter, realizujac kolejne etapy przetwarzania strumienia danych. Metoda collect natomiast kończy przetwarzanie strumienia i ma za parametr obiekt klasy Collector, który tworzy nową kolekcję i dodaje do niej dane ze strumienia, na rzecz którego została wywołana. W szczególności taki kolektor, budujący listę, można uzyskać za pomocą statycznej metody Collectors.toList().

Programowanie funkcyjne - wprowadzenie Możemy zatem zapisać poprzedni przykład uzyskania listy kwadratów tych elementów listy src, które są mniejsze od 10: import static java.util.stream.collectors.tolist; //... List<Integer> src = Arrays.asList(5, 72, 10, 11, 9); List<Integer> target = src.stream().filter(n -> n < 10).map(n -> n * n).collect(tolist()); Może trochę więcej tu kodu, niż poprzednio, ale za to nie musimy definiować własnych interfejsów (metody strumieniowe korzystają z interfejsów z pakietu java.util.function, które pokrywają częste przypadki użycia lambda-wyrażeń). Ale co najważniejsze mamy dużo większą swobodę działania. Możemy np. filtrować kwadraty liczb, czyli najpierw wykonać map(), a później filter(): List<Integer> num = Arrays.asList(1, 3, 5, 10, 9, 12, 7); List<Integer> out = num.stream().map(n -> n*n).filter(n -> n > 80).collect(toList()); co da w wyniku listę liczb: [100, 81, 144] 6

Programowanie funkcyjne - wprowadzenie Możemy też ulepszyć poprzedni przykładowy fragment, który selekcjonował pracowników do podwyżki. Teraz nie tylko zostanie wybrana odpowiednia grupa pracowników, ale też podwyżki zostaną zrealizowane: List<Employee> emp =... emp.stream().filter(e -> e.getage() > 30 && e.getsalary() < 4000).forEach(e -> e.setsalary(e.getsalary()*1.1)); emp.foreach( e -> System.out.printf("%s %.0f\n", e, e.getsalary()) ); Ten fragment wyprowadzi na konsolę: Kowal Jan 3740 Warto zwrócić uwagę, że zastosowano tu dwa razy metodę foreach. Pierwsze jej użycie dotyczyło strumienia zwracanego przez filter(...) i polegało na wykonaniu podanej operacji (ustalenia nowej pensji) na wszystkich elementach zwróconej sekwencji. Takie foreach, tak jak collect, jest jedną z metod, która kończy operacje strumieniowe. Drugie foreach zastosowano wobec kolekcji (listy pracowników) dla wyprowadzenia informacji. Jest to jeden z przykładów nowych (domyślnych) metod w interfejsach kolekcyjnych, którym jako argumenty można podawać lambda-wyrażenia odpowiednich rodzajów. 7

Interfejsy funkcyjne i lambda-wyrażenia 8 Jeżeli zestaw metod, deklarowanych w interfejsie, zawiera tylko jedną metodę abstrakcyjną (wyłączając dodane deklaracje abstrakcyjnych publicznych niefinalnych metod z klasy Object), to taki interfejs nazywa się funkcyjnym (SAM - Single Abstract Method). Przykłady interfejsów funkcyjnych: interface SAMA { void dowork(int n);//zawiera jedną metodę abstrakcyjną, interface SAMB { void dowork(string s); @Override boolean equals(object); // przedefiniowuje metodę equals z klasy Object, interface SAMC { void dowork(collection c);//metoda abstrakcyjna default public void done() { System.out.println("Done"); //metoda domyślna (default), ma implementację

Interfejsy funkcyjne i lambda-wyrażenia 9 Interfejsy funkcyjne zostały wybrane jako środek realizacji lambda-wyrażeń w Javie 8. Każde lambda-wyrażenie musi odpowiadać jakiemuś interfejsowi funkcyjnemu i jest typu wyznaczanego przez tego rodzaju interfejsy. W doborze odpowiedniego interfejsu funkcyjnego do lambdawyrażenia kompilator stosuje deskryptor funkcji (function descriptor) interfejsu funkcyjnego, który opisuje parametry typu (gdy interfejs jest sparametryzowany) oraz typy parametrów, typ wyniku i ew. typ zgłaszanego wyjątku metody interfejsu. Definiując interfejsy funkcyjne, warto stosować adnotację @FunctionalInterface, dzięki której kompilator może sprawdzić, czy rzeczywiście dany interfejs jest funkcyjny i poinformować nas o ew. błędach; w dokumentacji i kodzie widać od razu, że dany interfejs może być stosowany z lambdawyrażeniami. Składnia lambda-wyrażenia: gdzie (lista_parametrów) -> ciało_lambda lista_parametrów oznacza rozdzielone przecinkami deklaracje argumentów przekazywanych lambda-wyrażeniu (jak w nagłówku metody); ciało_lambda to jedno wyrażenie lub blok instrukcji, ujęty w nawiasy {. Uwaga. Jeśli typy parametrów mogą być określone przez kompilator w wyniku konkludowania typów (typy inferring), to w deklaracji parametrów można pominąć typy, a wtedy, gdy parametr jest jeden, można pominąć nawiasy okalające listę parametrów.

Interfejsy funkcyjne i lambda-wyrażenia Rozważmy prosty przykład lambda-wyrażenia, które otrzymuje jako argument liczbę całkowitą i zwraca jej wartość powiększoną o 1: (int n) -> { return n+1; Aby w ogóle coś takiego zapisać w programie, musimy mieć odpowiedni interfejs funkcyjny. Załóżmy, że mamy następujący interfejs (widoczny w kontekście kompilacji): interface IntProcessor { int process(int n); Wtedy tego lambda-wyrażenia możemy użyć wszędzie tam, gdzie może wystąpić typ IntProcessor, czyli m.in. w deklaracji zmiennej, przy przypisaniach czy przy przekazywaniu argumentów i zwrocie wyników. 10

Interfejsy funkcyjne i lambda-wyrażenia //Użycie lambda-wyrażeń w przypisaniach, przy przekazywaniu //argumentów i zwrocie wyników z metod class LamSample { //... static void arrop(int[] arr, IntProcessor p) { //... static IntProcessor getintprocessor() { return (int n) -> { return n + 1; ; //lub: n -> n + 1 public static void main(string[] args) { IntProcessor p = (int n) -> { return n + 1; ; // 1 int[] arr = {1, 2, 3; arrop(arr, (int n) -> { return n + 1; ); // 2 IntProcessor pl = getintprocessor(); // 3 //... 11

12 Interfejsy funkcyjne i lambda-wyrażenia Podanie lambda-wyrażeń w wierszach //1, //2, //3 jest swoistą deklaracją i nie powoduje jeszcze wykonania instrukcji ciała lambdy. Obliczenie lambda-wyrażenia nastąpi dopiero podczas wywołania metody interfejsu IntProcessor. Ale skąd ma się wziąć jej implementacja? Otóż, przy przetwarzaniu kodu źródłowego, kompilator natykając się na lambda-wyrażenie, określa jego typ (tzw. target type) na podstawie kontekstu użycia. W przykładzie jest to proste: w wierszu //1 typem lambda-wyrażenia jest IntProcessor, bo taka jest deklaracja zmiennej (IntProcessor p = (int n) -> { return n + 1; ; // 1); w wierszu //2 typem jest IntProcessor, bo tak jest określony drugi argument metody arrop arrop(arr, (int n) -> { return n + 1; ); // 2 Jednocześnie kompilator dodaje do klasy kod, który w fazie wykonania programu wesprze utworzenie odpowiedniej implementacji metody interfejsu funkcyjnego. W naszym przypadku int process(int a) {return a + 1; Wykonanie (obliczenie) lambda-wyrażenia odbywa się przez wywołanie tej metody.

Interfejsy funkcyjne i lambda-wyrażenia //Wykonanie lambda-wyrażeń static void arrop(int[] arr, IntProcessor p) { for (int i = 0; i < arr.length; i++) { arr[i] = p.process(arr[i]); // wykonanie lambda public static void main(string[] args) { IntProcessor p = (int n) -> { return n + 1; ; int x = p.process(1); // wykonanie lambda System.out.println(x); int[] arr = {1, 2, 3; arrop(arr, (int n) -> { return n + 1; ); System.out.println(Arrays.toString(arr)); W wyniku otrzymamy: 2 [2, 3, 4] 13

Interfejsy funkcyjne i lambda-wyrażenia Mamy tu do czynienia z lambda-wyrażeniem, które zwraca wynik. Mogą być też takie, które wyników nie zwracają, wtedy typem ich wyniku jest void (lub typ kompatybilny z void). Nasze przykładowe lambda-wyrażenie możemy znacznie uprościć. Kompilator może konkludować o typie parametru, więc w lambdzie możemy pominąć typ parametru. Możemy pominąć również () i {. arrop(arr, n -> n+1); arrop(arr, n -> n*10); Wyobraźmy sobie teraz, że oprócz interfejsu IntProcessor w kontekście kompilacji jest też widoczny interfejs funkcyjny StringProcessor. Dodajmy metodę, która wykorzystuje go do przetwarzania tablicy napisów interface IntProcessor { int process(int n); interface StringProcessor { String process(string n); public class Sample { static void arrop(int[] arr, IntProcessor p) { for (int i = 0; i < arr.length; i++) { arr[i] = p.process(arr[i] ); static void sarrop(string[] arr, StringProcessor p) { for (int i = 0; i < arr.length; i++) { arr[i] = p.process(arr[i]); public static void main(string[] args) {//... 14

Interfejsy funkcyjne i lambda-wyrażenia 15 Jakiego typu jest lambda-wyrażenie: n -> n + 1? Zależy to od kontekstu użycia. Gdy w metodzie main napiszemy np. int[] arr = {1, 2, 3; arrop(arr, n -> n+1); to na podstawie konkludowania typów lambda-wyrażenie będzie typu IntProcessor, a gdy napiszemy String[] sarr = {"Ala", "kot", "pies"; sarrop(sarr, n -> n+1); to, w wyniku konkluzji, typem tego lambda stanie się StringProcessor. Mamy tu do czynienia z wyrażeniami wielotypowymi (polytype expressions), czyli takimi, które mogą mieć różne typy w zależności od kontekstu użycia. Lambda-wyrażenia stanowią jeden z przypadków wyrażeń wielotypowych w Javie. Stanie się to jeszcze bardziej widoczne (i bardziej funkcjonalne), gdy nieco uogólnimy kody, stosując metody sparametryzowane.

Interfejsy funkcyjne i lambda-wyrażenia //Lambda-wyrażenia - konkludowanie typów interface Processor<T> { T process(t val); public class ArrProc { public static <T> void processarr(t[] arr, Processor<T> p ){ for (int i = 0; i < arr.length; i++) { arr[i] = p.process (arr[i]); public static void main(string[] args) { String[] sa = { "a", "b", "c" ; Integer[] ia = (1, 2, 3); processarr(sa, v -> v+l); processarr(ia, v -> v+l); // konkludowanie typów // konkludowanie typów processarr (sa, v -> v.touppercase()); // konkludowanie typów processarr(ia, v -> v*v); System.out.println(Arrays.toString(sa)) ; System.out.println(Arrays.toString(ia)); //wynik: [A1, B1, C1] [4, 9, 16] // konkludowanie typów 16

Interfejsy funkcyjne i lambda-wyrażenia Jak już widzieliśmy, lambda-wyrażenia można stosować jako uproszczenie w użyciu anonimowych klas wewnętrznych, implementujących interfejsy funkcyjne. Podobnie jak w lokalnych klasach wewnętrznych lambda-wyrażenie ma dostęp do wszystkich składowych klasy otaczającej, przy czym pola tej klasy mogą być przez lambda-wyrażenie modyfikowane; do zmiennych lokalnych, ale muszą one albo być deklarowane ze specyfikatorem final albo być efektywnie finalne (effective final). Inaczej niż w anonimowych klasach wewnętrznych lambda-wyrażenie nie wprowadza nowego zasięgu widoczności i dostępności, co oznacza m.in., że zmienna this jest referencją do obiektu klasy, w której tworzone jest lambdawyrażenie (w klasie anonimowej this oznacza obiekt tej klasy); słowo kluczowe super oznacza nadklasę obiektu (klasy), w której tworzone jest lambda-wyrażenie; jeśli lambda-wyrażenie występuje w bloku, niedopuszczalne jest przesłanianie zmiennych lokalnych z bloku otaczającego (w klasie lokalnej anonimowej mamy nowy zasięg widoczności, więc możemy używać tych samych identyfikatorów zmiennych, co w bloku otaczającym). 17

Referencje do metod i konstruktorów 18 Często definicja lambda-wyrażenia sprowadza się do wywołania metody istniejącej klasy lub utworzenia jej obiektu. Wtedy zamiast wywołania tej metody w lambdawyrażeniu możemy zastosować referencję do metody lub konstruktora. Są cztery rodzaje takich referencji (symbolicznie przez x oznaczamy jeden parametr lub listę parametrów w nawiasach okrągłych): NazwaKlasy::nazwa_metody_statycznej Klasa::metStat - odpowiada lambda-wyrażeniu x -> Klasa.metStat(x) NazwaKlasy::nazwa_metody_niestatycznej Klasa::met - odpowiada lambda-wyrażeniu x -> x.met() zmienna_niestatyczna::nazwa_metody_niestatycznej Klasa v; v::met - odpowiada lambda-wyrażeniu x -> v.met(x) NazwaKlasy::new Klasa::new - odpowiada lambda-wyrażeniu x -> new Klasa(x)

Referencje do metod i konstruktorów 19 Naturalnie, liczba i typy parametrów oraz typ wyniku metody (konstruktora), do których używamy referencji, muszą odpowiadać deskryptorowi funkcji jakiegoś interfejsu funkcyjnego (który zostanie dobrany do realizacji lambda-wyrażenia). Najlepiej zobaczyć to na przykładzie. Załóżmy, że w kontekście kompilacji widoczne są interfejsy funkcyjne: interface Transformer<T,S> { T transform(s v); interface Operator<R,T,S> { R oper(t v1, S v2); oraz następująca klasa Animal: class Animal{ String type; public Animal(String type) { this.type = type; public String tostring() { return "Animal{type=" + type + "";

Referencje do metod i konstruktorów 20 Zastosowanie referencji do metod i konstruktorów ilustruje poniższy kod: public class MetRef { static <T,S> List<T> create(list<s> src, Transformer<T,S> t){ List<T> target = new ArrayList<>(); for (S s : src) target.add(t.transform(s)); return target; static <R,T,S> List<R> create(list<t> src1, List<S> src2, Operator<R,T,S> o){ List<R> res = new ArrayList<>(); for (int i = 0; i < src1.size(); i++){ res.add(o.oper(src1.get(i), src2.get(i))); return res;

Referencje do metod i konstruktorów public static void main(string[] args) { List<String> s = Arrays.asList( "pies", "kot", "ryba" ); // zamiast List out = create(s, e -> e.touppercase()); System.out.println(out); //[PIES, KOT, RYBA] // możemy napisać out = create(s, String::toUpperCase); System.out.println(out); //[PIES, KOT, RYBA] String text = "pies i kot są w domu, a ryba pływa"; // zamiast out = create(s, e -> text.indexof(e)); System.out.println(out);//[0, 7, 24] // możemy napisać out = create(s, text::indexof); System.out.println(out);//[0, 7, 24] //zamiast out = create(s, e -> new Animal(e)); System.out.println(out); //[Animal{type=pies, Animal{type=kot, Animal{type=ryba] // możemy napisać out = create(s, Animal::new); System.out.println(out); //[Animal{type=pies, Animal{type=kot, Animal{type=ryba] 21

Gotowe interfejsy funkcyjne 22 Jak już wspominaliśmy, najczęściej nie musimy tworzyć własnych interfejsów funkcyjnych. Po pierwsze, w Javie już od lat jest wiele interfejsów typu SAM (np. znany nam FileFilter czy Runnable). Po drugie, w wersji 8 pojawił się pakiet java.util.function, w którym zdefiniowano wiele interfejsów funkcyjnych dla częstych przypadków użycia lambda-wyrażeń, np. Predicate<T>, Function<S, T>, UnaryOperator<T>, Supplier<T>, Consumer<T>(), BiPredicate<U,V>, BiFunction<U,V,R>, BinaryOperator<T>, BiConsumer<U,V>. Przedstawimy, teraz interfejsy z których już korzystaliśmy: A)ActionListener. Ma on jedną metodę void actionperformed(actionevent ae) B)FileFilter. Ma on jedną metodę boolean accept(file f), wykorzystywaną do selekcji obiektów plikowych np. w trakcie listowania zawartości katalogu metodą listfiles (tu jako argument podajemy właśnie implementację metody accept). Zatem dla uzyskania tablicy plików z danego katalogu dir, mających podane rozszerzenie ext i czas modyfikacji późniejszy od podanego time możemy napisać: File[] files = new File(dir).listFiles( f -> f.isfile() && f.getname().endswith("."+ext) && f.lastmodified() > time);

Gotowe interfejsy funkcyjne 23 C)Comparator. Jak pamiętamy, ma jedną metodę int compare(t obiekt1, T obiekt2). Przy porównywaniu i sortowaniu możemy więc używać wygodnych lambda-wyrażeń, np. do uporządkowania listy napisów wg ich długości: List<String> lst = Arrays.asList("ala", "ma", "kota", "i", "pieska"); Collections.sort(lst, (s1, s2) -> s2.length() - s1.length()); System.out.println(lst); Powyższy fragment wyprowadzi: [pieska, kota, ala, ma, i] D)Runnable. Kod zliczający czas (np. w trakcie jakiejś interakcji użytkownika z programem) za pomocą lambda-wyrażenia, pasującego do deskryptora funkcji (public void run()) moglibyśmy napisać tak, jak pokazuje kod: Future<?> ftask = Executors.newSingleThreadExecutor().submit( () -> { int sec = 0; while(true) { sec++; try { Thread.sleep(1000); catch(interruptedexception exc) { return; System.out.println(sec/60 + ":" + sec%60); ); //... JOptionPane.showMessageDialog(null, "Close dialog to stop"); ftask.cancel(true);

Lambda-wyrażenia w gotowych metodach W Javie 8 pojawiły się nowe metody w standardowych klasach i interfejsach (metody statyczne i/lub domyślne), których argumentami mogą być lambda-wyrażenia. Jest ich całkiem sporo. Omówimy krótko wybrane z nich. W interfejsie Iterable dodano domyślną metodę foreach(consumer op) (interfejs Consumer<T> ma metodę void accept(t t) umożliwiającą wykonywanie operacji na przekazanym obiekcie bez zwracania wyniku) dzięki której na dowolnych elementach zestawu danych, określanego przez implementację Iterable (m.in. na dowolnej kolekcji), możemy wykonywać podaną operację op. Aby przyjrzeć się bliżej działaniu foreach, zdefiniujmy metodę zwiększającą wartości elementów przekazanej listy liczb całkowitych. Argumentem lambda-wyrażenia w foreach będzie kolejny element listy. Nie mamy dostępu do indeksu tego elementu, zatem nie mogąc przeprowadzić modyfikacji za pomocą metody set(i,val) interfejsu List, musimy stworzyć i zwrócić nową listę, która będzie zawierać zmienione wartości : static List<Integer> increase(list<integer> inlist, int n) { List<Integer> out = new ArrayList<>(); inlist.foreach(e -> out.add(e+n)); return out; public static void main(string[] args) { List<Integer> in = Arrays.asList(1, 7, 11, 19); System.out.println(in); //[1, 7, 11, 19] in = increase(in, 2); System.out.println(in); //[3, 9, 13, 21] 25

Lambda-wyrażenia w gotowych metodach foreach różni się zdecydowanie od zwykłych pętli (for i rozszerzonego for). Gdybyśmy np. chcieli przerwać zwiększanie o 1 wartości elementów, gdy natrafimy na wartość > 9: inlist.foreach(e -> { if (e > 9) break; out.add(e+n); ); to uzyskalibyśmy błąd w kompilacji. W foreach nie wolno stosować instrukcji break. Również instrukcja return ma inne znaczenie niż zwykle. Nie zwraca sterowania z metody, w której użyliśmy foreach, kończy jedynie wykonanie lambda-wyrażenia dla aktualnie przetwarzanego argumentu. W takim kontekście: void show(list<integer> inlist) { inlist.foreach(e -> { ); //... if (e == 11) return; System.out.println(e); show(arrays.aslist(1, 7, 11, 19)); na konsoli nie uzyskamy 1, 7 tylko 1, 7, 19. W metodzie foreach instrukcja return przechodzi do następnej iteracji (działa tak jak continue w normalnych" pętlach). 26

Lambda-wyrażenia w gotowych metodach Aby z lambda-wyrażenia uzyskać zewnętrzną instrukcję return, zwracającą sterowanie z metody, w której to lambda-wyrażenie jest wykonywane, korzystamy z wyjątków: void show(list<integer> inlist) { try { inlist.foreach(e -> { ); if (e == 11) throw new RuntimeException(); System.out.println(e); catch(runtimeexception exc) { return; Dla inlist = [1,7,11,19] na konsoli uzyskamy tylko dwa elementy: 1 i 7. Tutaj dodatkowo zamiast ogólnego RuntimeException należałoby zdefiniować własną klasę wyjątku np. ExternalReturnFromLambda. W przeciwnym razie każdy wyjątek typu RuntimeException, powstający przy wykonaniu operacji w ciele lambda-wyrażenia, powodowałby zakończenie działania otaczającej metody. 27

Lambda-wyrażenia w gotowych metodach Drobną innowacją, jest dodanie domyślnej metody foreachremaining do interfejsu Iterator, która wykonuje podane lambda-wyrażenie na wszystkich w danym momencie pozostałych elementach (być może po wcześniejszym użyciu metody next() Iteratora). Utwórzmy listę wynikową, której pierwszy element będzie sumą dwóch pierwszych elementów listy wejściowej, a pozostałe będą zwiększone o 1: List<Integer> specialop(list<integer> inlist) { List<Integer> out = new ArrayList<>(); Iterator<Integer> it = inlist.iterator(); out.add(it.next() + it.next()); it.foreachremaining(e -> out.add(e+1)); return out; // in jest listą [1, 7, 11, 19] in = specialop(in); System.out.println(in); Ten fragment kodu wyprowadzi na konsolę: [8, 12, 20]. Naturalnie, gdy foreach iteruje po obiektach klas modyfikowalnych, możemy zmieniać ich stany: employeelist.foreach(e -> e.setsalary(e.getsalary()*1.2)); Metoda setsalary() ma typ wyniku void (co jest zgodne z kontraktem dla interfejsu Consumer, używanym pod spodem" lambda-wyrażenia w metodzie foreach), wobec tego mogliśmy zastosować w ciele lambdy pojedyncze wyrażenie. Gdyby metoda zwracała wynik, w lambda-wyrażeniu należałoby użyć bloku instrukcji, z których ostatnią byłoby proste return. 28

Lambda-wyrażenia w gotowych metodach Wygodnie używa się foreach, gdy lambda-wyrażeniem jest referencja do metody niezwracającej wyniku, której argumentem jest obiekt iterowanego zestawu. Sztandarowym przykładem jest wypisywanie informacji na konsolę. Zamiast pisać: kolekcja.foreach(e -> System.out.println(e)); możemy użyć referencji do metody println: kolekcja.foreach (System.out::println); Bardzo użyteczne jest foreach zdefiniowane jako domyślna metoda interfejsu Map. Lambda-wyrażenie jest tu BiConsumerem, czyli ma dwa argumenty (klucz i wartość kolejnego wejścia w mapie) oraz typ wyniku void. Dzięki temu przeglądanie map jest znacznie łatwiejsze, np. zamiast for(map.entry me : map.entryset()) { ; // tu coś robimy z kluczem, uzyskanym przez me.getkey() // i z wartością spod klucza pobraną przez me.getvalue() piszemy: map.foreach ( (key, val) -> robimy coś z key i val ); 29

Lambda-wyrażenia w gotowych metodach 30 Istotne dodatki pojawiły się w interfejsie Comparator. Wiemy już, że tam, gdzie trzeba dostarczyć komparatora możemy podać lambda-wyrażenie. Załóżmy, że mamy klasę Employee z polami: String lname (nazwisko), String fname (imię), Integer age (wiek), Double salary (pensja) z odpowiednimi metodami get zwracającymi wartość danego pola. Mając listę pracowników lemps i używając domyślnej metody sort interfejsu List, możemy sortować listę wg różnych kryteriów, np. wg wieku: List<Employee> lemps =... System.out.println(lemps); // oryginalna lista lemps.sort((el, e2) -> el.getage().compareto(e2.getage())); System.out.println(lemps); po posortowaniu w wyniku dostaniemy: [Jeż Jan (34,4100.0), Es Joe (41,3600.0), As Ala (27,3700.0)] [As Ala (27,3700.0), Jeż Jan (34,4100.0), Es Joe (41,3600.0)] Zauważmy, że w lambda-wyrażeniu, reprezentującym komparator, wywołujemy na rzecz obu porównywanych obiektów metodę klasy Employee (getage), a ponieważ wynikiem jest Integer (implementujący interfejs Comparable), to do porównania wartości możemy zastosować metodę compareto.

Lambda-wyrażenia w gotowych metodach 31 Użyteczna domyślna metoda removeif(predicate) została zdefiniowana w interfejsie Collection (interfejs Predicate<T> ma metodę boolean test(t v)). Usuwa ona wszystkie elementy kolekcji, których wartości spełniają podany w postaci predykatu warunek, np. Set<String> slist = new HashSet(Arrays.asList( "Cypr wyspa", "Madagaskar - wyspa", "Krabi", "Londyn")); slist.removeif(s ->!s.endswith("wyspa")); slist.foreach(system.out::println); da w wyniku: Cypr - wyspa Madagaskar wyspa W standardowych klasach i interfejsach Javy znajdziemy wiele innych gotowych metod, które pozwalają podawać jako argumenty lambda-wyrażenia.

Przetwarzanie strumieniowe Strumień (nie należy mylić tego pojęcia ze strumieniami wejścia-wyjścia) stanowi sekwencję elementów, ale nie przechowuje tych elementów w strukturach danych, tylko konstytuuje potok (połączenie) różnych operacji na elementach. Potok operacji ma swoje źródło (można to nazwać też źródłem strumienia), który może być np. kolekcją, tablicą lub napisem (ciągiem znaków). Operacje, łączone w potoku, mogą być pośrednie - dające w wyniku inny strumień (np. map, filter), przy czym operacje te mogą być bezstanowe - niewymagające od strumienia znajomości wartości poprzednio przetwarzanych elementów (np. filter lub foreach); takie operacje są bardzo efektywne; stanowe - wymagające od strumienia pamiętania stanów innych, od akurat przetwarzanego, elementów (np. sortowanie elementów strumienia); terminalne - kończące przetwarzanie strumienia (np. collect i foreach); po wykonaniu operacji terminalnej nie można wykonać na strumieniu żadnej innej operacji; skracające (short-circuit) - takie, które powodują, że wcześniejsze w potoku operacje pośrednie kończą działanie, gdy rezultat operacji skracającej jest jasny; operacje te mogą być zarówno pośrednie, jak i terminalne. 32

Przetwarzanie strumieniowe 33 Strumienie charakteryzują się ważnymi cechami. Operacje pośrednie są leniwe (lazy operations), czyli nie są wykonywane ani nie generują żadnych wartości, dopóki nie zostanie wywołana operacja terminalna, a elementy strumienia są przetwarzane tylko w takim zakresie, jaki jest potrzebny do uzyskania wymaganego wyniku (np. gdy rezultat operacji skracającej jest w pełni określony). Elementy strumienia mogą być generowane ad hoc za pomocą generatorów i iteratorów (ogólnie takie strumienie są nieskończone; w praktyce zawsze jakoś kończymy ich przetwarzanie, np. generator liczb pseudolosowych może generować nieskończoną ich sekwencję, a my ograniczamy ją do pierwszych 100). Operacje na strumieniach mogą być wykonywane równolegle (w odrębnych wątkach), przy czym bardzo łatwo to możemy zadekretować (np. za pomocą metody parallel), a podziałem pracy między równolegle wykonujące się podzadania zajmie się JVM. We wszystkich operacjach strumieniowych podajemy lambda-wyrażenia, co sprzyja zwięzłości i czytelności kodu.

Przetwarzanie strumieniowe 34 Strumienie są obiektami klasy implementującej interfejs Stream. Strumienie możemy uzyskać m.in.: od kolekcji - za pomocą metody stream() z interfejsu Collection, np. list.stream(); od tablic-za pomocą statycznej metody stream() z klasy Arrays, np. Arrays. stream(array); od napisów (strumień znaków) - za pomocą metody chars(); od podanych wartości, w tym tablic obiektowych (varargs), za pomocą metody Stream.of(zestaw wartości); od plików (strumień wierszy pliku) - za pomocą statycznej metody lines(...) z klasy Files lub lines() z klasy BuferredReader; od katalogów (strumień reprezentujący drzewo katalogowe obiektów plikowych) - za pomocą statycznej metody walk (...) lub find(...) z klasy Files; od archiwów (np. ZipFile lub JarFile; tu strumień reprezentuje uporządkowane elementy archiwum entries) za pomocą metody stream(); od wyrażenia regularnego, reprezentowanego przez obiekt klasy Pattern - za pomocą metody splitasstream(napis), zwracającej strumień symboli napisu, wyłuskanych za pomocą tego wyrażenia; za pomocą generowania elementów metodami Stream.generate(...) lub Stream.iterate(... ); za pomocą statycznej metody ints() klasy Random (strumień pseudolosowych liczb całkowitych; przez leniwe połączenie strumieni statyczną metodą Stream.concat(strum1, strum2).

Przetwarzanie strumieniowe 35 Podstawowe operacje pośrednie: map(function f) - zwraca strumień z elementami tego strumienia przekształconymi za pomocą podanej funkcji (transformacja elementów). flatmap(function f) - zwraca strumień z elementami tego strumienia przekształconymi za pomocą podanej funkcji, przy czym zastosowanie tej funkcji musi dawać strumienie, a po odwzorowaniu ich elementy będą stanowić jeden strumień (nastąpi swoiste spłaszczenie, połączenie różnych zestawów danych w jeden). filter(predicate p) - zwraca strumień elementów, dla których predykat p daje true (selekcja elementów). distinct() - zwraca strumień elementów, różniących się w sensie equals() (wybór niepowtarzających się elementów) - operacja stanowa. sorted(...) - zwraca strumień posortowanych elementów (w porządku naturalnym lub wg podanego komparatora) - operacja stanowa. unordered() - zwraca nieuporządkowany strumień. limit(int n) - zwraca strumień zawierający n pierwszych elementów tego strumienia - operacja skracająca. generate(supplier s) - zwraca strumień elementów, z których każdy jest tworzony przez podanego dostawcę", np. strumień stałych lub losowych wartości.

Przetwarzanie strumieniowe 36 iterate(t init, UnaryOperator op) - zwraca strumień tworzony przez iteracyjne zastosowanie operatora op wobec inicjalnej wartości init. substream(...) - zwraca część strumienia (np. od 10 elementu do końca lub od 5 do 20) - operacja skracająca. parallel () - zwraca strumień, na którym operacje będą wykonywane równolegle. sequential() - zwraca strumień, na którym operacje będą wykonywane sekwencyjnie. Wybrane operacje terminalne: allmatch(predicate p) - zwraca true, jeśli wszystkie elementy strumienia spełniają warunek p, false w przeciwnym razie. anymatch(predicate p) - j.w., ale pytanie brzmi: czy jakikolwiek element strumienia spełnia warunek; jest to operacja skracająca. nonematch(predicate p) - j.w, czy żaden element strumienia nie spełnia podanego warunku - operacja skracająca. findany() - zwraca dowolny element strumienia jako obiekt typu Optional, zawierający wartość tego elementu lub wartość pustą, jeśli strumień jest pusty - operacja skracająca. findfirst() - zwraca pierwszy element strumienia (jako Optional z jego wartością lub wartością pustą, gdy strumień jest pusty) - operacja skracająca. long count() - zwraca liczbę elementów strumienia.

Przetwarzanie strumieniowe 37 void foreach(consumer c) - wykonuje podane działanie na każdym elemencie strumienia; ale kolejność przetwarzania nie musi być taka sama, jak kolejność w zestawie, na który nałożono strumień (np. elementy listy mają swoją kolejność, ale foreach na strumieniu związanym z listą może wykonywać działania w innej kolejności). foreachordered(consumer) - j.w., ale jeśli dane, od których uzyskano strumień, mają swoją kolejność, to przy przetwarzaniu zostanie ona zachowana. reduce(...) - wykonuje redukcję elementów strumienia, czyli ogólnie - na podstawie zestawu jego elementów, stosując wobec nich odpowiednie operacje akumulujące czy kombinujące, wytwarza pewną wynikową wartość (np. sumę). collect(...) - wykonuje tzw. redukcję modyfikowalną, akumulującą elementy strumienia do modyfikowalnego kontenera, takiego jak kolekcja, mapa, bufor znakowy, inny strumień. max(...) i min( ) - zwracają największy (najmniejszy) element strumienia w porządku określonym przez podany jako argument komparator. toarray( ) - zwraca tablicę elementów strumienia.

Przetwarzanie strumieniowe 38 Możemy teraz zająć się przykładowymi zastosowaniami. Będziemy przy tym używać klasy opisującej państwa. Załóżmy, że mamy plik z informacjami o krajach (zaczerpnięty z serwisu GeoNames, gdzie wymienione są nie tylko niepodległe państwa, ale również regiony, które mają odrębne kody ISO2; w informacjach tych nie ma gęstości zaludnienia, a kontynenty są dane tylko w postaci kodów). Na wiersze tego pliku możemy nałożyć strumień i łatwo je przetwarzać na różne sposoby. Utwórzmy najpierw listę obiektów klasy Country. Zastosujemy metody map i collect strumieni do tworzenia listy obiektów klasy na podstawie wierszy pliku: Przetwarzanie strumieniowe Path p = Paths.get("nazwa_pliku"); Stream<String> ls = Files.lines(p, Charset.defaultCharset()); List<Country> clist = ls.map(country::new).collect(collectors.tolist()); Tutaj map(country::new) tworzy strumień obiektów klasy Country (na wierszach pliku jest wywoływany jej konstruktor, który inicjuje pola na podstawie informacji ze stringa), a metoda collect posługuje się predefiniowanym obiektem-kolektorem (statyczne odwołanie do klasy Collectors), który dodaje elementy strumienia do nowo utworzonej listy. Klasa Collectors dostarcza wielu innych gotowych kolektorów do wykorzystania w metodzie collect (np. do tworzenia różnych rodzajów kolekcji, a także grupowania elementów strumienia pod kluczami w mapach).

Przetwarzanie strumieniowe Od utworzonej listy krajów możemy pobrać strumień i wykonywać na nim inne operacje, np. przez clist.stream().count() dowiemy się, że mamy informacje o 250 krajach. Spróbujmy teraz odnaleźć pierwszy kraj w strumieniu, którego nazwa zaczyna się na B" i pobrać jego nazwę. Optional<String> first = clist.stream().map(country::getname) // strumień wszystkich nazw.filter(s -> s.startswith("b")) //strumień nazw na B.findFirst(); // pierwsza nazwa na B String nazwa = first.get(); System.out.println(nazwa); Jako wynik findfirst() mamy Optional, bo w strumieniu może nie być żadnego elementu. Optional opakowuje uzyskaną wartość, musimy ją jeszcze pobrać za pomocą metody get(). Jednak jeśli jej nie ma (np. w filter wyszukujemy kraje o nazwie zaczynającej się na X), to wywołanie get() spowoduje wyjątek. 39

Przetwarzanie strumieniowe Aby tego uniknąć, powinniśmy zastosować następująca konstrukcję: Optional<String> first... String nazwa = first.orelse(...) której rezultatem będzie wynik get() (jeśli jest), albo podany przez nas argument metody orelse. Dobrze to widać w następującym fragmencie : static String firstwithprefix(stream<country> str, String p){ return str.map(country::getname).filter(s -> s.startswith(p)).findfirst().orelse("nie ma kraju na " + p); //... List<Country> clist =... String nazwa = firstwithprefix(clist.stream(), "B"); System.out.println(nazwa); nazwa = firstwithprefix(clist.stream(), "X"); System.out.println(nazwa); Fragment ten wyprowadzi: Bośnia and Herzegovina nie ma kraju na X 40