Fun with java 8
0 likes815 views
This document presents an overview of functional programming in Java 8, emphasizing its principles and advantages such as less code, enhanced expressiveness, and improved correctness. It discusses key features including lambda expressions, function references, and the Stream API, which facilitate declarative programming and efficient data processing. The document also addresses considerations for performance and best practices in applying functional programming techniques.
Fun with java 8
- 1. Fun with Java 8 Victor Perepelitsky twitter: @victor_perepel email: victor.prp@gmail.com git-hub: https://github.com/victor-prp/java8samples/
- 2. This presentation focuses on What functional programming is ? Why functional ? How to use java 8 for functional ?
- 3. Functional Programming In computer science, functional programming is a programming paradigm, a style of building the structure and elements of computer programs, that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions.
- 4. Functional Programming Functions Avoids mutable data Declarative Expressions
- 5. Why Functional? Less code Expressive code Correct code It is FUN Performance*
- 6. Functional building blocks in java 8 Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 9. Fun Reference - static fun p1
- 10. Fun Reference - static fun p1
- 11. Higher Order Function - Definition p1*
- 12. p1
- 14. java.util.function Function<T, R> accepts T, returns R BiFunction<T, U, R> accepts T and U, returns R Consumer<T> accepts T, returns void Supplier<T> accepts nothing, returns T Predicate<T> accepts T, returns boolean p1
- 15. Lambda - simple example p1
- 16. Lambda - formal definition Anonymous function (also function literal or lambda abstraction) is a function definition that is not bound to an identifier. Lambdas are often: 1. passed as arguments to higher-order functions, or 2. used to construct the result of a higher- order function that needs to return a function. p1
- 17. Lambda Anonymous function Passed as argument (common usage) In java 8 it is only syntactic sugar for function reference p1
- 18. Lambda p1
- 19. Monad In functional programming, a monad is a structure that represents computations defined as sequences of steps. A type with a monad structure defines what it means to chain operations, or nest functions of that type together http://en.wikipedia.org/wiki/Monad_% 28functional_programming%29p3
- 20. In Java 8 Stream is a Monad Chaining stream operations forming a stream pipeline p3 menu filter sorted map collect how to filter how to sort how to map how to collect List<String >
- 21. Java 8 Stream â A stream represents a sequence of elements and supports different kind of operations to perform computations upon those elements â Stream operations are either intermediate or terminal. â Intermediate operations return a stream so we can chain multiple intermediate operations. â Terminal operations are either void or return a non-stream result. p3
- 22. Letâs see it again p3 menu stream filter sorted map collect how to filter how to sort how to map how to collect List<String > intermediate final
- 23. Stream vs Collection â Like a collection, a stream provides an interface to a sequenced set of values of a specific element type â Because collections are data structures, theyâre mostly about storing and accessing elements with specific time/space complexities â Streams are about expressing computations such as filter, sorted, and map that â Collections are about data; streams are about computations p2
- 24. Basic building blocks summary Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 25. Why Functional? Less code Expressive code Correct code It is FUN Performance* p2
- 26. Imperative p5
- 27. Declarative p5
- 28. Referential transparency An expression is said to be referentially transparent if it can be replaced with its value without changing the behavior of a program (in other words, yielding a program that has the same effects and output on the same input). The opposite term is referential opaqueness. http://en.wikipedia.org/wiki/Referential_transparency_ (computer_science) p2**
- 29. Pure Function 1. Given same input, always provides same output 2. Execution does not cause observable side- effects 1+2 = Referential Transparency p2
- 30. Why pure functions? Allows automatic optimizations by a compiler Minimizes moving parts Easy to test Increases decoupling p2
- 31. Pure functions - is it enough? doIt1(..) and doIt2(..) - are pure functions? but we wrote them in two different ways?! p2
- 32. Imperative p5
- 33. Declarative p5
- 34. Refactor toward functional Letâs combine pure functions with declarative style Example: Design a system that returns top UK and US music albums p3
- 35. p3*
- 36. p3
- 37. p3
- 38. We want to search albums By Name and By Year p3*
- 39. version 1 p3
- 40. version 2 - pass behaviour p3
- 41. version 3 - compact naming p3
- 42. We want the data in specific form Example: get years of hits albums p3*
- 43. version 1 p3
- 44. version 2 p3
- 45. We want the data reduced Example: get the oldest album p3
- 46. version 1 p3
- 47. version 2 p3
- 48. So far we saw Pure functions vs Non pure... Declarative vs Imperative... Functions as building blocks⊠Passing behavior vs static behavior⊠Function reference vs Lambda...
- 49. Additional useful techniques Execution guarantee Builder pattern Composition Currying and Partial application p4
- 50. We want to Guarantee correct locking by Write it once and Let it use in multiple places p4*
- 52. Builder pattern StringBuilder is a good example: p4
- 53. How builder pattern helps? We already saw it - streams We can create our own builders to introduce fluent interfaces p4
- 54. Can we search by multiple filters? p4
- 55. We actually want this: p4*
- 56. How can we achieve this? p4
- 57. Composition p4
- 60. Search with Partial Application V1 p4
- 61. Search with Partial Application V2 p4
- 62. Why Functional? Less code Expressive code Correct code It is FUN Performance*
- 63. Performance - is it better in java8? Depends: â Pure functions may be memoized â Stream API may be heavier â There are more considerationsâŠ. p5
- 64. Performance - example We have doIt1 and doIt2 using both imperative and declarative styles p5
- 65. Imperative p5
- 66. Declarative p5
- 67. Performance - example Letâs run it 1000 times Results: â doIt1 took: 15ms â doIt2 took: 63ms p5
- 68. Declarative - improved version p5
- 69. Performance - example Letâs run it 1000 times Results: â doIt1 took: 15ms â doIt2 took: 63ms â doIt4 took: 30ms p5
- 70. Can Java 8 be used for functional programming? Function reference Composition Lambda Stream API Currying and Partial Application*
- 71. Any problems? We have to define an interface for a function Special treatment for functions with primitives Partial application is not straightforward Typed exceptions
- 72. Guidelines Aim to declarative Aim to immutability Aim to pure functions Consider function ref over lambda Be aware of performance when using stream Use multi paradigm programming
- 76. all sample are available at: https://github. com/victor-prp/java8samples