JDK8 Functional API

1. JDK8 Functional API Justin Lin caterpillar@openhome.cc http://openhome.cc 1

2. Agenda •Lambda in 10 mins •Lambda & Refactoring •Stream... •Reduction •Parallelism •A little Monad 2

3. Lambda in 10 mins 3

4. •Anonymous class •Lambda expressions with no argument 4

5. •Lambda expressions with arguments •Type inference JDK8 built-in functional interface 5

6. •Target typing •Method reference •Default method 6

7. Lambda & Refactoring 7

8. •The most beneficial way of using lambdas is introducing them into your existing code base. 8

9. •Introduce a method. Finding tracks over one minute 9

10. Collecting names from each track 10

11. Filtering tracks over a minute and collecting to a List Mapping tracks to names and collecting to a Set 11

12. An Intermediate operation, why don't we chain them together? Filtering tracks over a minute, mapping tracks to names and collect to a Set Well, what's stream? We may just use map(Track::getName) instead. 12

13. Stream... 13

14. •The stream method returns a Stream instance, not a new collection. •The filter or map method returns a Stream instance, too. •The collect(toSet()) returns a Set<String> instance as a result. 14

15. •The Stream instance draw data from the source, could be a collection, an array, a generator function, or an I/O channel. –collection.stream() –Arrays.stream(array) –Files.lines(Paths.get(fileName)) –… •An intermediate operation, such as filter, produces a new Stream instance. •A terminal operation, such as forEach, produces a non-stream result. 15

16. •Intermediate operations are lazy… •You don't have to close streams provided by JDK8 except Files.line, list and walk. •Compared with the eager way. 16

17. •Why does Stream's findFirst return Optional? •Maybe there's no the first one … Why not null? •Which method of Stream returns Optional? –Optional<T> findAny() –Optional<T> findFirst() –Optional<T> max(Comparator<? super T> comparator) –Optional<T> min(Comparator<? super T> comparator) –Optional<T> reduce(BinaryOperator<T> accumulator) Null sucks. Doug Lea I call it my billion- dollar mistake. Tony Hoare 17

18. •Whether an Optional instance containing a value or not is optional, so make appropriate checks to avoid bugs. •Creating an Optional instance… –Optional.empty() –Optional.of(value) –Optional.ofNullable(value) •Getting the value orXXX? –T orElseGet(Supplier<? extends T> other) –T orElseThrow(Supplier<? extends X> expsp) 18

19. •Checking by yourself? •Invoking the specified consumer if a value is present. •Invoking the specified consumer if the value matches the given predicate. NoSuchElementException if no value. 19

20. •Wait! I see wired method signatures in previous examples….Supplier, Consumer, Predicate…What're those types? •Important functional interfaces used time and time again in JDK8. Interface Arguments Returns Consumer<T> T void Function<T, R> T R Predicate<T> T boolean Supplier<T> none T 20

21. •Consumer<T> accept T void 21

22. •Function<T, R> –Sub interface: UnaryOperator<T> •Predicate<T> apply T R apply T T test T boolean Predicate Function 22

23. •Supplier<T> •Fail fast examples if an Optional instance contains no value. •Avoiding performance overhead. get none T NoSuchElementException 23

24. •To avoid performance overheads, the streams library has primitive versions. They have a clear- cut naming convention. •Streams for primitives. –IntStream –LongStream –DoubleStream •Functional interfaces for primitives. –XxxConsumer –XxxPredicate –XxxSuppiler –XxxToOooFunction accept xxx void test xxx boolean getAsXxx none xxx applyAsOoo xxx ooo 24

25. •Functional interfaces for mapping objects and primitives. –XxxFunction<R> –ToXxxFunction<T> •Several functional interfaces starts with Bi- prefix. Take BiConsumer<T, U> for an example. apply xxx R applyAsXxx T xxx accept (T, U) void 25

26. Reduction 26

27. •How long of all long tracks? •Reduce? Sometimes it's called as fold(left). 27

28. •The max length? •Reduction operations –Terminal operations that return one value by reducing the contents of a stream. –(Reduce, fold or combine, whatever you call it.) 28

29. •How to reduce the elements of a stream to a more complex object, such as a collection? •Using collect methods… 29

30. •The Collectors.toXxx method, such as toSet, doesn't return a Set but a Collector. •The Collectors provides factory methods for creating out-of-box Collector … •Grouping … •Grouping and mapping … 30

31. •Grouping and reducing … •Grouping and averaging … •The stream library picks an appropriate implementation for you. 31

32. •You might wish to collect your values into a specific Collection. •Implementing your own Collector… –supplier、accumulator、combiner、 finisher Creating a new mutable result container Reducing a value into a mutable result container Accepting two partial results and merging them Performing an optional final transform on the container 32

33. •Implementing your own Collector, a simple example … 33

34. Parallelism 34

35. •Concurrency –Two tasks are making progress at overlapping time periods. •Parallelism –Two tasks are happening at literally the same time. Task 1 Task 2 Core 1 Core 2 Task 1 Task 2 Core 1 Core 2 35

36. •Changing a single method call… •Making an operation execute in parallel… 36

37. •The Java runtime performs a concurrent reduction if … –The stream is parallel. –The Collector has the characteristic Collector.Characteristics.CONCURRENT –Either the stream is unordered, or the Collector has the characteristic Collector.Characteristics.UNORDERED. •Built-in concurrent-supported collector –groupingByConcurrent –toConcurrentMap 37

38. •Ordering… •The combining function must be associatve when preforming concurrent reduction… –1 + 3 + 8 + 9 + 2 + 5 + 4 + 6 + 7 –(1 + 3) + 8 + (9 + 2) + 5 + (4 + 6 + 7) –1 + (3 + 8 )+ 9 + 2 + (5 + 4 + 6 + 7) 38

39. •Interference •Performance –Data size、source data structure、number of cores、cost per element … •Simply speaking… –Executing in parallel without worrying about tools doesn't mean there is a free lunch. Don't do this!! ConcurrentModifiedException 39

40. A little Monad 40

41. •Hey, you forget this … why not refactoring it? •Yes! Coming now … But … What's flatMap? 41

42. •The idea of flatMap is from Monad … •Monad? Let's google it …. •Great! something can be eaten … XD 42

43. •A suggestion: getting started from map and flatMap of Optional … •The map method can change the following … 43

44. •If your getXXX methods return Optional, you can change the following … 44

45. •Monad in Java 8 ? –Optional –Stream –CompletableFuture •Several starting points … –http://openhome.cc/Gossip/Java/FlatMap.html –http://www.codedata.com.tw/java/jdk8- completablefuture/ –http://www.slideshare.net/mariofusco/monadic-java 45

46. Summary •Functional? You've done that when you are … –Refactoring your existing code … –Applying filter, map, reduce … –Returning Optional instead of null … –Considering issues of parallelism when using parallel tools, such as parallelStream … –Or even using those monadic API of Java 8 … •These are Java ways of functional style; pragmatic ways of understanding and introducing Lambda/Functional API 46

47. Exercise: –Completing Chapter 1 –Using functional API to refactor Customer again 47 MonsterSupreme Lambda 就是重構(重構(程式碼)) Lambda is a way to refactor refactored code

48. References •http://shop.oreilly.com/product/0636920030713.do •http://www.amazon.com/Refactoring-Improving- Design-Existing-Code/dp/0201485672 •http://docs.oracle.com/javase/tutorial/collections/streams/index.html •http://docs.oracle.com/javase/tutorial/collections/streams/reduction.html •http://openhome.cc/Gossip/Java/FlatMap.html •http://www.codedata.com.tw/java/jdk8- completablefuture/ •http://www.slideshare.net/mariofusco/monadic-java 48

49. Thanks!! Justin Lin caterpillar@openhome.cc http://openhome.cc 49