fun with java 8

Fun with Java 8Victor Perepelitsky

twitter: @victor_perepelemail: victor.prp@gmail.comgit-hub: 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