What’s New in Java 8
Introduction to Lambda Expression in Java 8
José Paumard
blog.paumard.org
@JosePaumard
What You Will Learn
The most useful new parts of Java 8
Lambda expressions
The Stream API and Collectors
And many bits and pieces
Java FX
Nashorn
Course Overview
Java 8 lambda expressions and Interfaces
Stream API and Collectors
Date and Time API
Strings, I/O and other bits and pieces
Rich interfaces: Java FX
Nashorn, a new Javascript engine for the JVM
Targeted Audience
This is a Java course
Basic knowledge of the main APIs
Generics
Collection API
Java I/O
Module Outline
Introduction to the « Lambda expressions »
Module Outline
Introduction to the « Lambda expressions »
The lambda syntax
Module Outline
Introduction to the « Lambda expressions »
The lambda syntax
Functional interfaces
Module Outline
Introduction to the « Lambda expressions »
The lambda syntax
Functional interfaces
Method references
Constructor references
Module Outline
Introduction to the « Lambda expressions »
The lambda syntax
Functional interfaces
Method references
Constructor references
How to process data from the Collection API?
What Is a Lambda Expression for?
A simple example
public interface FileFilter {
boolean accept(File file) ;
}
What Is a Lambda Expression for?
Let’s implement this interface
public class JavaFileFilter implements FileFilter {
public boolean accept(File file) {
return file.getName().endsWith(".java") ;
}
}
What Is a Lambda Expression for?
Let’s implement this interface
public class JavaFileFilter implements FileFilter {
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
}
And use it:
JavaFileFilter fileFilter = new JavaFileFilter();
File dir = new File("d:/tmp");
File[] javaFiles = dir.listFiles(fileFilter);
What Is a Lambda Expression for?
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
File dir = new File("d:/tmp");
File[] javaFiles = dir.listFiles(fileFilter);
What Is a Lambda Expression for?
The first answer is :
To make instances of anonymous classes easier to write
What Is a Lambda Expression for?
The first answer is :
To make instances of anonymous classes easier to write
and read!
A First Lambda Expression
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
A First Lambda Expression
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
We take the parameters
FileFilter filter = (File file)
A First Lambda Expression
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
and then…
FileFilter filter = (File file) ->
A First Lambda Expression
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
return this
FileFilter filter = (File file) -> file.getName().endsWith(".java");
A First Lambda Expression
Let’s use an anonymous class
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().endsWith(".java");
}
};
This is a Java 8 lambda expression:
FileFilter filter = (File file) -> file.getName().endsWith(".java");
So What Is a Java 8 Lambda Expression?
Answer: another way of writing instances of anonymous classes
Live coding : FileFilter, Runnable, Comparator
Several Ways of Writing a Lambda Expression
The simplest way:
FileFilter filter = (File file) -> file.getName().endsWith(".java");
Several Ways of Writing a Lambda Expression
The simplest way:
FileFilter filter = (File file) -> file.getName().endsWith(".java");
If I have more than one line of code:
Runnable r = () -> {
for (int i = 0; i < 5; i++) {
System.out.println("Hello world!");
}
};
Several Ways of Writing a Lambda Expression
If I have more than one argument:
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Three Questions About Lambdas
What is the type of a lambda expression?
Three Questions About Lambdas
What is the type of a lambda expression?
Can a lambda be put in a variable?
Three Questions About Lambdas
What is the type of a lambda expression?
Can a lambda be put in a variable?
Is a lambda expression an object?
What Is the Type of a Lambda Expression?
Answer: a functional interface
What Is the Type of a Lambda Expression?
Answer: a functional interface
What is a functional interface?
Functional Interface
A functional interface is an interface with only one abstract method
Functional Interface
A functional interface is an interface with only one abstract method
Example:
public interface Runnable {
run();
};
Functional Interface
A functional interface is an interface with only one abstract method
Example:
public interface Runnable {
run();
};
public interface Comparator<T> {
int compareTo(T t1, T t2);
};
Functional Interface
A functional interface is an interface with only one abstract method
Example:
public interface Runnable {
run();
};
public interface Comparator<T> {
int compareTo(T t1, T t2);
};
public interface FileFilter {
boolean accept(File pathname);
};
Functional Interface
A functional interface is an interface with only one abstract method
Methods from the Object class don’t count:
public interface MyFunctionalInterface {
someMethod();
/**
* Some more documentation
*/
equals(Object o);
};
Functional Interface
A functional interface can be annotated
@FunctionalInterface
public interface MyFunctionalInterface {
someMethod();
/**
* Some more documentation
*/
equals(Object o);
};
It is just here for convenience, the compiler can tell me whether the
interface is functional or not
Three Questions About Lambdas
What is the type of a lambda expression?
Answer: a functional interface
Can a lambda be put in a variable?
Is a lambda expression an object?
Can I Put a Lambda Expression in a Variable?
Answer is yes!
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Can I Put a Lambda Expression in a Variable?
Answer is yes!
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Consequences: a lambda can be taken as a method parameter, and
can be returned by a method
Three Questions About Lambdas
What is the type of a lambda expression?
Answer: a functional interface
Can a lambda be put in a variable?
Answer: yes!
Is a lambda expression an object?
Is a Lambda an Object?
This question is tougher than it seems…
Is a Lambda an Object?
Let’s compare the following:
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Comparator<String> c =
new Comparator<String>(String s1, String s2) {
public boolean compareTo(String s1, String s2) {
Integer.compare(s1.length(), s2.length());
}
};
Is a Lambda an Object?
Let’s compare the following:
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Comparator<String> c =
new Comparator<String>(String s1, String s2) {
public boolean compareTo(String s1, String s2) {
Integer.compare(s1.length(), s2.length());
}
};
A lambda expression is created without using « new »
Three Questions About Lambdas
What is the type of a lambda expression?
Answer: a functional interface
Can a lambda be put in a variable?
Answer: yes!
Is a lambda expression an object?
The answer is complex, but no
Three Questions About Lambdas
What is the type of a lambda expression?
Answer: a functional interface
Can a lambda be put in a variable?
Answer: yes!
Is a lambda expression an object?
The answer is complex, but no
Exact answer: a lambda is an object without an identity
Functional Interfaces Toolbox
New package : java.util.function
With a rich set of functional interfaces
Package java.util.function
4 categories:
Supplier
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Package java.util.function
4 categories:
Consumer
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
Package java.util.function
4 categories:
Consumer / BiConsumer
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
@FunctionalInterface
public interface BiConsumer<T, U> {
void accept(T t, U u);
}
Package java.util.function
4 categories:
Predicate
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
Package java.util.function
4 categories:
Predicate / BiPredicate
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
@FunctionalInterface
public interface BiPredicate<T, U> {
boolean test(T t, U u);
}
Package java.util.function
4 categories:
Function
@FunctionalInterface
public interface Function<T, R> {
R apply (T t);
}
Package java.util.function
4 categories:
Function / BiFunction
@FunctionalInterface
public interface Function<T, R> {
R apply (T t);
}
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply (T t, U u);
}
Package java.util.function
4 categories:
Function / UnaryOperator
@FunctionalInterface
public interface Function<T, R> {
R apply (T t);
}
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
}
Package java.util.function
4 categories:
BiFunction / BinaryOperator
@FunctionalInterface
public interface Function<T, U, R> {
R apply (T t, U u);
}
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {
}
More Lambda Expressions Syntax
Most of the time, parameter types can be omitted
Comparator<String> c =
(String s1, String s2) ->
Integer.compare(s1.length(), s2.length());
Becomes:
Comparator<String> c =
(s1, s2) ->
Integer.compare(s1.length(), s2.length());
Method References
This lambda expression:
Function<String, String> f = s -> s.toLowerCase();
Can be written like that:
Function<String , String> f = String::toLowerCase;
Method References
This lambda expression:
Consumer<String> c = s -> System.out.println(s);
Can be written like that:
Consumer<String> c = System.out::println;
Method References
This lambda expression:
Comparator<Integer> c = (i1, i2) -> Integer.compare(i1, i2);
Can be written like that:
Comparator<Integer> c = Integer::compare;
So What Do We Have so Far?
A new concept: the « lambda expression », with a new syntax
So What Do We Have so Far?
A new concept: the « lambda expression », with a new syntax
A new interface concept: the « functional interface »
So What Do We Have so Far?
A new concept: the « lambda expression », with a new syntax
A new interface concept: the « functional interface »
Question: how can we use this to process data?
How Do We Process Data in Java?
Where are our objects?
How Do We Process Data in Java?
Where are our objects?
Most of the time: in a Collection (or maybe a List, a Set or a Map)
How Do We Process Data in Java?
Where are our objects?
Most of the time: in a Collection (or maybe a List, a Set or a Map)
Can I process this data with lambdas?
List<Customer> list = ...;
list.forEach(customer -> System.out.println(customer));
How Do We Process Data in Java?
Where are our objects?
Most of the time: in a Collection (or maybe a List, a Set or a Map)
Can I process this data with lambdas?
List<Customer> list = ...;
list.forEach(customer -> System.out.println(customer));
Or:
List<Customer> list = ...;
list.forEach(System.out::println);
Can I Process This Data with Lambdas?
The good news is: yes!
Can I Process This Data with Lambdas?
The good news is: yes!
We can write:
List<Customer> list = ...;
list.forEach(System.out::println);
Can I Process This Data with Lambdas?
The good news is: yes!
We can write:
List<Customer> list = ...;
list.forEach(System.out::println);
But… where does this forEach method come from?
Can I Process This Data with Lambdas?
The good news is: yes!
We can write:
List<Customer> list = ...;
list.forEach(System.out::println);
But… where does this forEach method come from?
Adding a forEach method on the Collection interface breaks the
compatibility: all the implementations have to be refactored!
How to Add Methods to Iterable?
Without breaking all the existing implementations?
public interface Iterable<E> {
// the usual methods
void forEach(Consumer<E> consumer);
}
How to Add Methods to Iterable?
Without breaking all the existing implementations?
public interface Iterable<E> {
// the usual methods
void forEach(Consumer<E> consumer);
}
Refactoring these implementations is not an option
How to Add Methods to Iterable?
If we cant put the implementation in ArrayList, then…
public interface Iterable<E> {
// the usual methods
default void forEach(Consumer<E> consumer) {
for (E e : this) {
consumer.accept(e);
}
}
}
Default Methods
This is a new Java 8 concept
It allows to change the old interfaces without breaking the existing
implementations
Default Methods
This is a new Java 8 concept
It allows to change the old interfaces without breaking the existing
implementations
It also allows new patterns!
Default Methods
This is a new Java 8 concept
It allows to change the old interfaces without breaking the existing
implementations
It also allows new patterns!
And by the way…
Default Methods
This is a new Java 8 concept
It allows to change the old interfaces without breaking the existing
implementations
It also allows new patterns!
And by the way…
Static methods are also allowed in Java 8 interfaces!
Examples Of New Patterns
Predicates
Predicate<String> p1 = s -> s.length() < 20;
Predicate<String> p2 = s -> s.length() > 10;
Examples Of New Patterns
Predicates
Predicate<String> p1 = s -> s.length() < 20;
Predicate<String> p2 = s -> s.length() > 10;
Predicate<String> p3 = p1.and(p2);
Examples Of New Patterns
Predicates
Predicate<String> p1 = s -> s.length() < 20;
Predicate<String> p2 = s -> s.length() > 10;
Predicate<String> p3 = p1.and(p2);
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
}
Examples Of New Patterns
Predicates
Predicate<String> id = Predicate.isEqual(target);
Examples Of New Patterns
Predicates
Predicate<String> id = Predicate.isEqual(target);
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Summary
The new « lambda expression » syntax
A lambda expression has a type : a functional interface
Definition of a functional interface, examples
Method and constructor references
Iterable.forEach method
Default and static methods in interfaces, examples
