Functional programming with Java 8
19 likes6,932 views
The presentation by Victor Perepelitsky discusses functional programming in Java 8, focusing on its principles, benefits, and how to apply it using features like functions, lambda expressions, and the Stream API. It emphasizes the advantages of functional programming such as less code, expressiveness, correctness, and performance improvements, while also exploring concepts like pure functions and referential transparency. Practical examples illustrate the use of Java 8 functions and the challenges of adopting a functional style in programming.
Functional programming with Java 8
- 1. Functional Programming with Java 8 Victor Perepelitsky slides: http://www.slideshare.net/victorperepelitsky/fun-with-java-8 twitter: @victor_perepel email: [email protected] 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_prog p3
- 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_(com puter_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
Editor's Notes
- #8: part 1 - fun def