Free your lambdas

@JosePaumard#FreeLambdas
Free your Lambdas
Java SE 8

Agenda
Tutorial session: we will start at the very beginning!
…and explore how to build functional interfaces to design
new APIs
This is about lambdas and functional interfaces
So not much about Streams & Collectors

@JosePaumard
@JosePaumard
https://github.com/JosePaumard
https://www.slideshare.net/jpaumard
https://www.youtube.com/user/JPaumard

Questions?
#FreeLambdas

A first example
What is this code doing?
Comparator<Person> cmp = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getLastName().compareTo(p2.getLastName());
}
};

A first example
@Override
int cmp = p1.getLastName().compareTo(p2.getLastName());
if (cmp == 0) {
return p1.getFirstName().compareTo(p2.getFirstName());
} else {
return cmp;
}
}
};

A first example
@Override
if (cmp == 0) {
cmp = p1.getLastName().compareTo(p2.getFirstName());
if (cmp == 0) {
return p1.getAge() - p2.getAge();
} else {
return cmp;
}
} else {
return cmp;
}
}
};

A first example
@Override
if (cmp == 0) {
cmp = p1.getFirstName().compareTo(p2.getFirstName());
if (cmp == 0) {
return p1.getAge() - p2.getAge();
} else {
return cmp;
}
} else {
return cmp;
}
}
};

A first example
Comparator<Person> cmp = Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparing(Person::getAge);

A closer look at the Comparator
Suppose we want to sort strings of characters
1) We create a comparator:
Comparator<String> comparator = new Comparator<String>() {
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
};

Suppose we want to sort strings of characters
1) We create a comparator:
2) We pass it to the right method:
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
};
Arrays.sort(strings, comparator); Collections.sort(list, comparator) ;

What did we do?

What did we do?
We passed a piece of code as a parameter to a method
And this method will use this code later

Why did we use an instance of an anoymous class?

Why did we use an instance of an anoymous class?
Because there is no other way in Java 7!

Another way of writing it
Our comparator:
public int compareTo(String s1, String s2) {
return Integer.compare(s1.length(), s2.length()) ;
}
}

Another way of writing it
Our comparator:
Becomes:
public int compareTo(String s1, String s2) {
return Integer.compare(s1.length(), s2.length()) ;
}
}
Comparator<String> comparator =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length()) ;

Back to the Comparator interface
The Comparator interface…
public interface Comparator<T> {
public int compare(T t1, T t2) ;
}

becomes a functional interface in Java 8
}

becomes a functional interface in Java 8
because it has a single abstract method
}

A functional interface can be annotated
But it is optional
@FunctionalInterface
}

So…
Writing a lambda is a matter of finding what interface to
implement
The type of a lambda is always known at compile time
The method to write a lambda is always the same:
- copy / paste the block of parameters
- little ASCII art arrow
- implement the method

A weird thing…
We wrote this code:
The forEach() method is defined on the Iterable interface
List<String> strings = ...;
strings.forEach(
System.out::println // method reference (bound instance)
) ;

A weird thing…
We wrote this code:
The forEach() method is defined on the Iterable interface
Do we really want to refactor all the Collection API?
List<String> strings = ...;
strings.forEach(
System.out::println // method reference (bound instance)
) ;

Default methods
Breaking the backward compatibility is not possible in Java
The way interfaces work has been modified:
public interface Iterable<E> {
// usual methods
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
}

Default methods
We can now add methods in interfaces with their
implementation
Those are « normal » methods
It is a new concept of interface, not a new concept of
method

Default & static methods
We can now add methods in interfaces with their
implementation
Those are « normal » methods
It is a new concept of interface, not a new concept of
method
And static methods are allowed too!

Back to the functional interface
A functional interface is an interface
with only one abstract method
So default & static methods do not count

So…
Interfaces in Java 8:
- Functional interfaces to write lambda expressions
- Default methods, can be used to compose them
- Static methods, can be used as factory
We have better readability, better robustness…
and better performances!
(Youtube: Lambda a peek under the hood by B. Goetz)

Package java.util.function
4 categories of functional interfaces:
Consumer
Supplier
Function
Predicate

Consumer t -> {};
Supplier () -> t;
Function t -> u;
Predicate t -> true;

Consumer t -> {}; s -> System.out.println(s);
Supplier () -> t; () -> new Balloon();
Function t -> u; person -> person.getAge();
Predicate t -> true; age -> age > 20;

Runnable () -> {};
Supplier () -> t; () -> new Balloon();

Runnable () -> {}; () -> logger.log(message);
Supplier () -> t; () -> new Ballon();

Back to the Comparator
Let us write a comparator of people
- Using an anonymous class
- Then a lambda

Method reference
There are 4 types of method references
Nom Syntaxe
Static RefType::staticMethod
Bound instance expr::instMethod
Unbound instance RefType::instMethod
Constructor ClassName::new

Method reference
There are 4 types of method references
Lambda Method Reference
d -> Math.sin(d) Math::sin
s -> System.out.println(s) System.out::println
(s, t) -> s.compareTo(t) String::compareTo
name -> new Person(name) Person::new

What about patterns?
Let us talk about the GoF

The factory pattern

The factory pattern
The registry & builder patterns

Conclusion
Lambdas are not just a nice way of writing instances of
anonymous classes
Functional interfaces + default methods + factory methods
provide new ways of implementing well-known patterns for
our applications & APIs

Thank you!

Free your lambdas

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Free your lambdas

Similar a Free your lambdas (20)

Más de José Paumard

Más de José Paumard (15)

Último

Último (20)

Free your lambdas