Functional Programming in Java

09 Sept 2015
Functional Programming in Java
Jim Bethancourt
@jimbethancourt

1
1 What is Functional Programming?
2 What are the Benefits?
3 Functions
4 Lambdas
5 Streams
6 Terminal Operators
7 Intermediate Operators
8 Collectors
9 Optional
Agenda

2
What is Functional Programming?
Functions have no state
They don’t change
• the world around them
• their input
• access global state
Given the same input, they produce the same output
Just like a function in math: f(x) = y
What is Functional Programming

3
What is Functional Programming?
Let’s face it – Computer application codebases have gotten HUGE!
How big are the codebases you work on?
Mutable state is frequently difficult to manage
Have you forgotten to set a flag too?
Imperative style code is often difficult to read
Don’t tell me what you’re doing – just do it!
Why Functional Programming?

4
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

5
What are the Benefits?
Functional Programs are easier to:
• Scale
• Read
• Test
Faster!

6
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

7
Functions
Functions are first-class citizens:
• They can be assigned, passed, and returned
just like variables!
• They don’t mutate state, they transform values
• Treating functions as values is known as First-
class Functions or Higher-order Programming
Functions as First-Class Citizens

8
Functions
Functions are isolated
But what if I want secondary output / side
effects?
Use a Consumer<T>!
Functions Are Isolated

9
Functions
public void convertTemps() {
DoubleUnaryOperator convertFtoC =
expandedCurriedConverter(-32, 5.0/9, 0);
S.o.p(convertFtoC.applyAsDouble(98.6));
}
static DoubleUnaryOperator
expandedCurriedConverter(double w, double y, double z) {
return (double x) -> (x + w) * y + z;
}
Example of Functional Programming

10
Functions
Imperative vs Declarative
Imperative
How
Mutate
Side-effects
Pass objects
Hard to compose
Declarative
What
Transform
Pure
Pass functions too
Functional composition

11
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

12
Lambdas
A lambda is an inline functional definition
They can see and use nearby values, but can’t
change them
Closures can change nearby variables.
Java 8 lambdas are NOT closures since they
require all variables to be final
What are Lambdas

13
Lambdas
Before:
Comparator<Apple> byWeight = new Comparator<Apple>() {
public int compare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight());
}
};
After (with lambda expressions):
Comparator<Apple> byWeight =
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
Before and After Lambdas

14
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

15
Streams
A sequence of elements supporting sequential and
parallel aggregate operations. (from Java 8 Javadoc)
Streams allow for you to manipulate collections of data
in a declarative way.
Operations can be chained together to form an
expressive processing pipeline
Streams perform internal iteration behind the scenes,
allowing you to focus on what rather than how
Streams can easily be parallelized by calling
parallelStream() -- YMMV
What is a Stream?

16
Streams
Each intermediate operation performed on a stream returns another stream
This allows for any number of intermediate operations to be performed on a stream of elements
These operations include but are not limited to
filter()
map()
flatMap()
distinct()
Streams don’t perform an evaluation until they reach their terminal operation is reached, such as
reduce()
collect()
sum(), max(), min(), etc.
Streams Return Streams, and they’re Lazy!!!

17
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

18
Terminal Operators
Terminal operators trigger processing and return a
value. reduce(), count(), anyMatch(), and
summaryStatistics() are examples of terminal
operations
Once a terminal operation takes place, that instance of
the stream is dead and no longer usable, and no further
processing can take place on it.
The End is Coming!

19
Terminal Operators
Streams can only be traversed once, so how can we
reuse the code we wrote?
Assign the nonterminated stream operation to a stream
supplier object!
Supplier<Stream<String>> streamSupplier =
() -> Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> s.startsWith("a"));
streamSupplier.get().anyMatch(s -> true); // ok
streamSupplier.get().noneMatch(s -> true); // ok
One Time Traversal and Stream Reuse

20
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

21
Intermediate Operators
Intermediate Operators perform mapping / transforming and filtering operations on a stream of
elements.
Any number of intermediate operations can be performed on a stream of elements.
people.stream()
.filter(person -> person.getGender() == Gender.MALE)
.map(person -> new Person(person.getName().toUpperCase(), person.getGender(), person.getAge()))
.forEach(System.out::println);
Transforming! More Than Meets the Eye!

22
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

23
Collectors
Collectors allow for objects to be accumulated to be
passed back to a result container such as a Collection or a
Map
Transformations may take place once all elements are
accumulated, but this is not required.
Collector<Employee, ?, Map<Department, Integer>>
summingSalariesByDept =
Collectors.groupingBy(Employee::getDepartment,
summingSalaries);
Finishing the Stream

24
Collectors
Collectors require 3 things:
Empty instance of the output type
Operator that can put an element into that output type
Operation that can combine two of the output type
Collectors within collectors are possible too!
Requirements of Collectors

25
3 Functions
4 Lambdas
5 Streams
8 Collectors
9 Optional

27
Optional
I’m tired of NPEs!

28
Optional
Instead of returning a null object, return an Optional!
Use Optional as a Safe Return Type

29
Optional
public class Person {
private Optional<Car> car;
public Optional<Car> getCar() { return car; }
}
public class Car {
private Optional<Insurance> insurance;
public Optional<Insurance> getInsurance() { return insurance; }
}
public class Insurance {
private String name;
public String getName() { return name; }
}
Putting Optional to Work

30
Optional
Empty optional creation
Optional<Car> optCar = Optional.empty();
Optional from a non-null value
Optional<Car> optCar = Optional.of(car);
Optional from a possibly null value
Optional<Car> optCar = Optional.ofNullable(car);
Creating Optionals

31
Optional
Optional<Insurance> optInsurance =
Optional.ofNullable(insurance);
Optional<String> name =
optInsurance.map(Insurance::getName);
Getting values in Optionals

32
Optional
This won’t compile!
Optional<Person> optPerson = Optional.of(person);
Optional<String> name =
optPerson.map(Person::getCar)
.map(Car::getInsurance)
.map(Insurance::getName);
Chaining Operations with Optionals

33
Optional
Instead, use flatMap()
public String getCarInsuranceName(Optional<Person> person) {
return person.flatMap(Person::getCar)
.flatMap(Car::getInsurance)
.map(Insurance::getName)
.orElse("Unknown");
}
Chaining Operations with Optionals

Functional Programming in Java

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Functional Programming in Java

Similaire à Functional Programming in Java (20)

Plus de Jim Bethancourt

Plus de Jim Bethancourt (13)

Dernier

Dernier (20)

Functional Programming in Java

Notes de l'éditeur