Functional aspects of java 8

Functional Aspects of Java 8
Shahadat Hossain Chowdhury (Jobaer)
Technical Project Manager
Cefalo AS

Things I will talk about
Lamda
Streams
Optional

Lambda structure
Parameters -> Body
(Apple a1, Apple a2) ->
a1.getWeight().compareTo(a2.getWeight());

We can use lambda to
parameterize behaviors

public class Apple {
private String color;
private Integer weight;
public Apple(color, weight) …
public String getColor() …
public void setColor(color) …
public Integer getWeight() …
public void setWeight(weight) …
}
There was an apple store ...

We want to filter all green apples

filterGreenApples(List<Apple> inventory){
List<Apple> result = new ArrayList<>();
for(Apple apple : inventory) {
if("green".equals(apple.getColor())) {
result.add(apple);
}
}
return result;
}
greenApples = filterGreenApples(inventory);
Attempt 1

Filter the “red” ones too!

List<Apple> filterByColor(inventory,color){
if(color.equals(apple.getColor())) {
result.add(apple);
}
}
return result;
}
filterByColor(inventory, "green");
filterByColor(inventory, "red");
Attempt 2

And filter also by “weight”

Attempt 3
List<Apple> filterApples(
inventory, color, weight, flag) {
if((flag && color.equals(apple.getColor()))
|| (!flag && apple.getWeight() >= weight)) {
result.add(apple);
}
}
return result;
}
filterApples(inventory, "green", 0, true);
filterApples(inventory, "red", 0, true);
filterApples(inventory, "", 150, false);

public interface ApplePredicate {
boolean test(Apple apple);
}
class GreenPredicate implements … {
@Override
public boolean test(Apple apple) {
return "green".equals(apple.getColor());
}
}
Attempt 4

HeavyPredicate implements ApplePredicate {
return apple.getWeight() >= 150;
}
}
RedAndHeavyPredicate implements … {
return "red".equals(apple.getColor())
&& apple.getWeight() >= 150;
}
}
Attempt 4 ...

filterApples(
inventory, ApplePredicate predicate) {
if(predicate.test(apple)) {
result.add(apple);
}
}
return result;
}
filterApples(inventory, new GreenPredicate());
filterApples(inventory, new AppleHeavyPredicate());
filterApples(inventory, new RedAndHeavyPredicate());
Attempt 4 ...

List<Apple> inventory = getInventory();
greenApples = filterApples(
inventory, new ApplePredicate() {
return "red".equals(apple.getColor());
}
});
Attempt 5 … anon class

greenApples = filterApples(
inventory,
apple -> "red".equals(apple.getColor()));
heavyApples = filterApples(
inventory,
apple -> apple.getWeight() >= 150);
Attempt 6 .. Power of lambda

public interface Predicate<T> {
boolean test(T t);
}
List<T> filter(List<T> list,
Predicate<T> p) {
List<T> result = new ArrayList<>();
for (T e : list) {
if (p.test(e)) {
result.add(e);
}
}
return result;
}
Final attempt .. more generic

greenApples = filter(
inventory, (Apple a) ->
"green".equals(a.getColor()));
heavyApples = filter(
inventory,
(Apple a) -> a.getWeight() >= 150);
numbers = Arrays.asList(1,2,3,4,5,6,7,8);
evenNumbers = filter(
numbers, (Integer i) -> i % 2 == 0);
Final attempt .. more generic

Lambda in a nutshell
● Anonymous
● Function
● Passed around
● Concise

Label l = new Label("...");
Button b = new Button();
b.addActionListener(new ActionListener() {
@Override
public void actionPerformed (
ActionEvent e) {
l.setText("Sending...");
}
});
Without lambda

b.addActionListener(
(ActionEvent e) -> l.setText("Sending.. ")
);
Using lambda

Thread regular = new Thread( new Runnable()
{
@Override
public void run() {
System.out.println("From runnable");
}
});
Traditional way

Thread lambda = new Thread(
() -> System.out.println("From lambda"));
With lambda

inventory.sort(new AppleComparator());
class AppleComparator implements
Comparator<Apple> {
@Override
public int compare(Apple a1, Apple a2) {
return a1.getWeight().compareTo(
a2.getWeight());
}
}
Sort with named comparator

inventory.sort(new Comparator<Apple>() {
@Override
public int compare(Apple a1, Apple a2) {
return a1.getWeight().compareTo(
a2.getWeight());
}
});
Sort with Anon. comparator

inventory.sort(
(a1, a2) ->
a1.getWeight().compareTo(
a2.getWeight()));
Sort with Lambda

inventory.sort(
comparing(Apple::getWeight));
Sort with method reference

inventory.sort(comparing(Apple::getWeight);
inventory.sort(
comparing(Apple::getWeight).reversed());
inventory.sort(
comparing(Apple::getColor).
thenComparing(Apple::getWeight));
Compose comparators

Predicate<Apple> redApple =
apple -> "red".equals(apple.getColor());
Predicate<Apple> notRedApple =
redApple.negate();
inventory.stream().filter(notRedApple);
Compose Predicates …

Compose Predicates
Predicate<Apple> redAndHeavy =
redApple.and(apple ->
apple.getWeight() > 150);
redApple
.and(a -> a.getWeight() > 150)
.or(a -> "green".equals(a.getColor()));

Compose Functions
Function<...> inc = a -> a + 1;
Function<...> dub = a -> a * 2;
Function<..> incThenDub = inc.andThen(dub);
incThenDub.apply(9) // returns 20
Function<..> incOfDub = inc.compose(dub);
incOfDub.apply(9) // returns 19

But where it can be used?
class Letter {
static String addHeader(String text) {
return "From Bob: " + text;
}
static String addFooter(String text) {
return text + "nKind regards";
}
static String checkSpelling(String text) {
return
text.replaceAll("labda", "lambda");
}
}

Compose Functions
Function<..> addHeader = Letter::addHeader;
Function<..> pipeline1 =
addHeader
.andThen(Letter::checkSpelling)
.andThen(Letter::addFooter);
Function<..> pipeline2 =
addHeader
.andThen(Letter::addFooter);

There’s more about lambda, but I
am not covering here

Domain class
public class Dish {
Dish(String name, int calories) ..
public String getName() ...
public int getCalories() ...
...
}

Get the low calorie dish names,
sorted by calorie

Java 7 approach ...
//First we get all the low cal dishes
List<Dish> lowCals = new ArrayList<Dish>();
for (Dish dish : menu) {
if(dish.getCalories() < 400){
lowCals.add(dish);
}
}

Java 7 approach ...
// Sort the dishes according to calorie
Collections.sort(lowCals, new
Comparator<Dish>() {
public int compare(Dish d1, Dish d2) {
return Integer.compare
(d1.getCalories(), d2.getCalories());
}
});
// And now get the names as result
List<String> lowCalNames = new ArrayList<>();
for (Dish lowCal : lowCals) {
lowCalNames.add(lowCal.getName());
}

Come to Java 8
List<String> newLowCalNames =
menu.stream()
.filter(d -> d.getCalories() < 400)
.sorted(comparing(Dish::getCalories))
.map(Dish::getName)
.collect(toList());

Traversable only once.
Traversing again will throw
IllegalStageException!

External iterator vs. internal
iterator
//External iteration
List<String> names = new ArrayList<>();
for(Dish d : menu) {
names.add(d.getName());
}
//Internal iteration
List<String> names = menu.stream()
.map(Dish::getName).collect(toList());

Stream operations
● Intermediate Operations
○ filter, map, limit, sorted,
distinct, skip etc.
● Terminal operations
○ forEach, count, collect, reduce

Reducing ...
Integer sum(List<Integer> numbers ) {
int result = 0;
for (Integer number : numbers) {
result = result + number;
}
return result;
}
Integer product(List<Integer> numbers) {
int result = 1;
for(Integer num : numbers) {
result = result * num;
}
return result;
}

Reducing
Integer sumByReduce =
ints.stream()
.reduce(0, (a, b) -> a + b);
Integer prodByReduce =
ints.stream()
.reduce(1, (a, b) -> a * b);

Streams api let’s you write code
that is ..
● Declarative
● Composable
● Parallelizable

I just touched the surface.
Have a look a the full api
http://docs.oracle.com/javase/8/docs/api/java/util/stream/package
-summary.html

He developed the Quicksort
Algorithm

He also invented another thing …

What’s wrong with this method?
String getCarInsuranceName(Person person){
return person.getCar()
.getInsurance()
.getName();
}

It may fail spectacularly with a
NullPointerException!

So we need to avoid nulls at any
cost!

Avoiding nulls - attempt 1
String getCarInsuranceName(Person person) {
if(person != null){
Car car = person.getCar();
if(car != null) {
Insurance ins = car.getInsurance();
if(ins != null){
return ins.getName();
}
}
}
return “Unknown”;
}

Avoiding nulls - early exit
String getCarInsuranceName(Person person) {
if(person == null) {
}
Car car = person.getCar();
if(car == null){
}
Insurance ins = car.getInsurance();
if(ins == null){
}
return ins.getName();
}

Problems with Null
● Source of error
● Bloats your code
● Breaks java philosophy
● Hole in the type system

Meet Optional
Optional<Car> optCar = Optional.empty();
Optional<Car> optCar = Optional.of(car);
Optional<Car> optCar =
Optional.ofNullable(car);

Working with Optional
Optional<Insurance> optInsurance =
Optional.ofNullable(insurance);
Optional<String> name =
optInsurance.map(Insurance::getName);
String value = name.orElse(“Unknown”);

Let’s refactor our previous code
Car getCar() .. // previous
Optional<Car> getCar() … // now
Insurance getInsurace() … // previous
Optional<Insurance> getInsurance() … // now
and so on ..

And then we may try ...
Optional<Person>
optPerson = Optional.ofNullable(person);
Optional<String> name = optPerson
.map(Person::getCar)
.map(Car::getInsurance)
.map(Insurance::getName);

But that doesn’t work ...
Optional<Person> optPerson =
Optional.of(person);
optPerson.map(Person::getCar)
//returns Optional<Optional<Car>>

Mighty ‘flatMap’ to the rescue

person.flatMap(Person::getCar)
will return a Optional<Car>
instead of
Optional<Optional<Car>>
This is what ‘flatMap’ does

Power of Optional and flatMap
String getCarInsuranceName(
Optional<Person> person) {
return
person.flatMap(Person::getCar)
.flatMap(Car::getInsurance)
.map(Insurance::getName)
.orElse(“Unknown”);
}

There are some other features
which isn’t covered here

So in general functional
programming lets us write code
that is ...

Learn some other functional
languages

https://www.edx.org/course/introduction-functional-programming-delftx-fp101x

https://www.coursera.org/course/progfun

https://www.coursera.org/course/reactive

Thank you very much!
Example code on github.
https://github.com/JobaerChowdhury/fpinjava
Follow me on twitter
@JobaerChowdhury
Find me on linkedin
http://bd.linkedin.com/in/jobaer

Functional aspects of java 8

More Related Content

What's hot

Similar to Functional aspects of java 8

Recently uploaded

Functional aspects of java 8