Uploaded byLivePerson
Functional programming with Java 8
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 withJava 8 Victor Perepelitsky slides: http://www.slideshare.net/victorperepelitsky/fun-with-java-8 twitter: @victor_perepel email: victor.prp@gmail.com git-hub: https://github.com/victor-prp/java8samples/
- 2. This presentation focuseson What functional programming is ? Why functional ? How to use java 8 for functional ?
- 3. Functional Programming In computerscience, 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 mutabledata Declarative Expressions
- 5. Why Functional? Less code Expressivecode Correct code It is FUN Performance*
- 6. Functional building blocksin java 8 Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 7.
- 8.
- 9. Fun Reference -static fun p1
- 10. Fun Reference -static fun p1
- 11. Higher Order Function- Definition p1*
- 12.
- 13.
- 14. java.util.function Function<T, R> acceptsT, 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 - simpleexample p1
- 16. Lambda - formaldefinition 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 asargument (common usage) In java 8 it is only syntactic sugar for function reference p1
- 18.
- 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 8Stream 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 itagain 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 blockssummary Function Function reference Lambda Predefined Java8 functions - java.util.function Stream API p2
- 25. Why Functional? Less code Expressivecode Correct code It is FUN Performance* p2
- 26.
- 27.
- 28. Referential transparency An expressionis 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. Givensame input, always provides same output 2. Execution does not cause observable side- effects 1+2 = Referential Transparency p2
- 30. Why pure functions? Allowsautomatic 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.
- 33.
- 34. Refactor toward functional Let’scombine pure functions with declarative style Example: Design a system that returns top UK and US music albums p3
- 35.
- 36.
- 37.
- 38. We want tosearch albums By Name and By Year p3*
- 39.
- 40. version 2 -pass behaviour p3
- 41. version 3 -compact naming p3
- 42. We want thedata in specific form Example: get years of hits albums p3*
- 43.
- 44.
- 45. We want thedata reduced Example: get the oldest album p3
- 46.
- 47.
- 48. So far wesaw 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 Executionguarantee Builder pattern Composition Currying and Partial application p4
- 50. We want to Guaranteecorrect locking by Write it once and Let it use in multiple places p4*
- 51.
- 52. Builder pattern StringBuilder isa good example: p4
- 53. How builder patternhelps? We already saw it - streams We can create our own builders to introduce fluent interfaces p4
- 54. Can we searchby multiple filters? p4
- 55. We actually wantthis: p4*
- 56. How can weachieve this? p4
- 57.
- 58.
- 59.
- 60. Search with PartialApplication V1 p4
- 61. Search with PartialApplication V2 p4
- 62. Why Functional? Less code Expressivecode Correct code It is FUN Performance*
- 63. Performance - isit better in java8? Depends: ● Pure functions may be memoized ● Stream API may be heavier ● There are more considerations…. p5
- 64. Performance - example Wehave doIt1 and doIt2 using both imperative and declarative styles p5
- 65.
- 66.
- 67. Performance - example Let’srun it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms p5
- 68. Declarative - improvedversion p5
- 69. Performance - example Let’srun it 1000 times Results: ● doIt1 took: 15ms ● doIt2 took: 63ms ● doIt4 took: 30ms p5
- 70. Can Java 8be used for functional programming? Function reference Composition Lambda Stream API Currying and Partial Application*
- 71. Any problems? We haveto define an interface for a function Special treatment for functions with primitives Partial application is not straightforward Typed exceptions
- 72. Guidelines Aim to declarative Aimto immutability Aim to pure functions Consider function ref over lambda Be aware of performance when using stream Use multi paradigm programming
- 76. all sample areavailable at: https://github.com/victor-prp/java8samples
Editor's Notes
- #8 part 1 - fun def