Date post: | 17-Jul-2015 |
Category: |
Software |
Upload: | victorperepelitsky |
View: | 119 times |
Download: | 1 times |
Fun with Java 8Victor Perepelitsky
twitter: @victor_perepelemail: [email protected]: https://github.com/victor-prp/java8samples/
This presentation focuses on
What functional programming is ?
Why functional ?
How to use java 8 for functional ?
Functional ProgrammingIn computer science, functional programming is a
programming paradigm, a style of building the structureand elements of computer programs, that treatscomputation as the evaluation of mathematical functionsand avoids changing state and mutable data. It is a declarativeprogramming paradigm, which means programming isdone with expressions.
Functional Programming
Functions
Avoids mutable data
Declarative
Expressions
Why Functional?Less code
Expressive code
Correct code
It is FUN
Performance*
Functional building blocks in java 8Function
Function reference
Lambda
Predefined Java8 functions - java.util.function
Stream APIp2
Basic Function Definition
p1*
Basic Function Usage
p1
Fun Reference - static fun
p1
Fun Reference - static fun
p1
Higher Order Function - Definition
p1*
p1
pureFun doItTwice
pureFun
pureFun
p1
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
Lambda - simple example
p1
Lambda - formal definitionAnonymous 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, or2. used to construct the result of a higher-
order function that needs to return a function.
p1
LambdaAnonymous function
Passed as argument (common usage)
In java 8 it is only syntactic sugar for function
reference
p1
Lambda
p1
MonadIn 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
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 >
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
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
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
Basic building blocks summaryFunction
Function reference
Lambda
Predefined Java8 functions - java.util.function
Stream APIp2
Why Functional?Less code
Expressive code
Correct code
It is FUN
Performance*p2
Imperative
p5
Declarative
p5
Referential transparencyAn 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**
Pure Function
1. Given same input, always provides same output
2. Execution does not cause observable side-
effects
1+2 = Referential Transparency
p2
Why pure functions?
Allows automatic optimizations by a compiler
Minimizes moving parts
Easy to test
Increases decoupling
p2
Pure functions - is it enough?
doIt1(..) and doIt2(..) - are pure functions?
but we wrote them in two different ways?!
p2
Imperative
p5
Declarative
p5
Refactor toward functional
Let’s combine pure functions with declarative style
Example: Design a system that returns top UK and US music albums
p3
p3*
p3
p3
We want to search albums
By Name
and
By Year
p3*
version 1
p3
version 2 - pass behaviour
p3
version 3 - compact naming
p3
We want the data in specific form
Example: get years of hits albums
p3*
version 1
p3
version 2
p3
We want the data reduced
Example: get the oldest album
p3
version 1
p3
version 2
p3
So far we sawPure functions vs Non pure...
Declarative vs Imperative...
Functions as building blocks…
Passing behavior vs static behavior…
Function reference vs Lambda...
Additional useful techniquesExecution guarantee
Builder pattern
Composition
Currying and Partial application
p4
We want to
Guarantee correct locking byWrite it onceandLet it use in multiple places
p4*
Execution guarantee
p4
Builder patternStringBuilder is a good example:
p4
How builder pattern helps?
We already saw it - streams
We can create our own builders to introduce fluent interfaces
p4
Can we search by multiple filters?
p4
We actually want this:
p4*
How can we achieve this?
p4
Composition
p4
Partial Application
p4
Search using match(...)
p4
Search with Partial Application V1
p4
Search with Partial Application V2
p4
Why Functional?Less code
Expressive code
Correct code
It is FUN
Performance*
Performance - is it better in java8?Depends:
● Pure functions may be memoized
● Stream API may be heavier
● There are more considerations….
p5
Performance - example
We have doIt1 and doIt2 using both imperative
and declarative styles
p5
Imperative
p5
Declarative
p5
Performance - example
Let’s run it 1000 times
Results:
● doIt1 took: 15ms
● doIt2 took: 63ms
p5
Declarative - improved version
p5
Performance - example
Let’s run it 1000 times
Results:
● doIt1 took: 15ms
● doIt2 took: 63ms
● doIt4 took: 30msp5
Can Java 8 be used for functional programming?
Function reference
Composition
Lambda
Stream API
Currying and Partial Application*
Any problems?
We have to define an interface for a function
Special treatment for functions with primitives
Partial application is not straightforward
Typed exceptions
GuidelinesAim to declarativeAim to immutabilityAim to pure functionsConsider function ref over lambdaBe aware of performance when using streamUse multi paradigm programming
all sample are available at: https://github.com/victor-prp/java8samples