Java 8 Streams & Collectors : the Leuven edition

JDK 8 & Lambdas
Lambdas, Streams & Collectors

@JosePaumard
Why were they introduced ?

@JosePaumard
Why were they introduced ?
How will they change the way we build
applications ?

@JosePaumard
Publisher: Addison-Wesley Professional;
1 edition November 10, 1994

@JosePaumard
In stock.
Ships from and sold by Amazon.com. Gift-wrap available.
Publisher: Addison-Wesley Professional;
1 edition November 10, 1994

Let’s introduce the lambdas
on a simple example

A very simple example
public class Person {
private String name ;
private int age ;
// constructors
// getters / setters
}
List<Person> list = new ArrayList<>() ;
A plain old bean…
… and a good old list

int sum = 0 ;
// I need a default value in case
// the list is empty
int average = 0 ;
for (Person person : list) {
sum += person.getAge() ;
}
if (!list.isEmpty()) {
average = sum / list.size() ;
}
Average of the ages

int sum = 0 ;
int n = 0 ;
int average = 0 ;
if (person.getAge() > 20) {
n++ ;
}
}
if (n > 0) {
average = sum / n ;
}
Trickier : average of the ages of people older than 20

Trickier : average of the ages of people older than 20
« imperative programming »
int sum = 0 ;
int n = 0 ;
int average = 0 ;
if (person.getAge() > 20) {
n++ ;
}
}
if (n > 0) {
average = sum / n ;
}

select avg(age)
from Person
where age > 20
… it does not have to be like that !
This is a description of the result

select avg(age)
from Person
where age > 20
… it does not have to be like that !
This is a description of the result
In that case, the DB server is free to compute the
result the way it sees fit
© SQL language, 1974

Person age age > 20 sum
1st step : mapping
map

1st step : mapping
Mapping :
- takes a list of a given type
- gives another list of a different type
- same number of elements
map

2nd step : filtering
filtermap

2nd step : filtering
Filtering :
- takes a list of a given type
- gives another list of a the same type
- less elements
filtermap

3rd step : reduction
reducefiltermap

3rd step : reduction
Reduction : agregation of all the elements
in a single one
Ex : average, sum, min, max, etc…
reducefiltermap

The JDK 7 way
Create an interface to model the mapper…
public interface Mapper<T, V> {
public V map(T t) ;
}

public class PersonToAgeMapper implements Mapper<Person, Integer> {
public Integer map(Person p) {
return p.getAge() ;
}
}
The JDK 7 way
… and create an implementation …
public V map(T t) ;
}

Mapper<Person, Integer> mapper = new Mapper<Person, Integer>() {
return p.getAge() ;
}
}
The JDK 7 way
… that could be anonymous
public V map(T t) ;
}

The JDK 7 way
We can do the same for the filtering
public interface Predicate<T> {
public boolean filter(T t) ;
}

public class AgePredicate implements Predicate<Integer> {
public boolean filter(Integer i) {
return i > 20 ;
}
}
The JDK 7 way
}

AgePredicate predicate = new Predicate<Integer>() {
public boolean filter(Integer i) {
return i > 20 ;
}
}
The JDK 7 way
}

The JDK 7 way
And for the reduction
public interface Reducer<T> {
public T reduce(T t1, T t2) ;
}

public class Sum implements Reducer<Integer> {
public Integer reduce(Integer i1, Integer i2) {
return i1 + i2 ;
}
}
The JDK 7 way
}

Reducer<Integer> reduction = new Reducer<Integer>() {
public Integer reduce(Integer i1, Integer i2) {
return i1 + i2 ;
}
}
The JDK 7 way
}

The JDK 7 way
So the whole map / filter / reduce looks like this
1) Create 3 interfaces public interface Mapper<T, V> {
public V map(T t) ;
}
}
}

The JDK 7 way
So the whole map / filter / reduce looks like this
1) Create 3 interfaces
2) Apply the pattern
List<Person> persons = ... ;
int sum =
persons.map(
new Mapper<Person, Integer>() {
return p.getAge() ;
}
})
.filter(
new Filter<Integer>() {
public boolean filter(Integer age) {
return age > 20 ;
}
})
.reduce(0,
new Reducer<Integer>() {
public Integer recude(Integer i1, Integer i2) {
return i1 + i2 ;
}
}
}) ;

mapper = new Mapper<Person, Integer>() {
public Integer map(Person person) {
return person.getAge() ;
}
}
The JDK 8 way
Let’s rewrite our mapper

public Integer map(Person person) { // 1 method
}
}
The JDK 8 way

return p.getAge() ;
}
}
The JDK 8 way
mapper = (Person person) ;
we take a
person p

}
}
The JDK 8 way
mapper = (Person person) -> ;
and then …

}
}
The JDK 8 way
mapper = (Person person) -> person.getAge() ;
… return the age of p

}
}
The JDK 8 way

The compiler can recognize this as an implementation of
Mapper
}
}
The JDK 8 way

What if …
… there is more than one statement ?
The return has to be explicit
mapper = Person person -> {
System.out.println("Mapping " + person) ;
}

What if …
…I have no return value ?
consumer = Person person -> p.setAge(p.getAge() + 1) ;

What if …
…I have more than one argument ?
Or :
reducer = (int i1, int i2) -> {
return i1 + i2 ;
}
reducer = (int i1, int i2) -> i1 + i2 ;

The JDK 8 way
How can the compiler recognize the implementation of
map() ?

The JDK 8 way
map() ?
1) There’s only one method in Mapper

The JDK 8 way
map() ?
2) Both the parameters and the return types are
compatible

The JDK 8 way
map() ?
2) Both the parameters and the return types are
compatible
3) Thrown exceptions (if any) are compatible

More lambdas
Writing more lambdas becomes natural :
mapper = (Person person) -> person.getAge() ; // mapper
filter = (int age) -> age > 20 ; // filter
reducer = (int i1, int i2) -> i1 + i2 ; // reducer

More lambdas
And most of the time, the compiler understands this :
The « parameter types » can be omitted
mapper = person -> person.getAge() ; // mapper
filter = age -> age > 20 ; // filter
reducer = (i1, i2) -> i1 + i2 ; // reducer

Just a remark on the reduction
How does it really work ?

Reduction
2 examples :
Caveat :
the result is always reproductible in serial
it’s not in parallel
Reducer r1 = (i1, i2) -> i1 + i2 ; // Ok
Reducer r2 = (i1, i2) -> i1*i1 + i2*i2 ; // Oooops

So far
A lambda expression is an alternative
to write instances of anonymous inner classes

Other syntaxes
Very often one writes
This syntax is also possible :
mapper = person -> person.getAge() ;
mapper = Person::getAge ; // non static method

Other syntaxes
Other example :
Or :
sum = (i1, i2) -> i1 + i2 ;
sum = Integer::sum ; // static method, new !
max = (i1, i2) -> i1 > i2 ? i1 : i2 ;
max = Integer::max ; // static method, new !

Other syntaxes
Other example :
toLower = String::toLowerCase ;
// !!!! NO NO NO !!!!
toLowerFR = String::toLowerCase(Locale.FRANCE) ;

Questions :
What model for a lambda ?

Questions :
Can I put a lambda in a variable ?

Questions :
Is a lambda an object ?

Modelization
A lambda is an instance of a « functional interface »
@FunctionalInterface
public interface Consumer<T> {
public void accept(T t) ;
}

Modelization
A lambda is an instance of a « functional interface »
- only one abstract method (methods from Object dont
count)
- can be annotated by @FunctionalInterface (optional)
@FunctionalInterface
public void accept(T t) ;
}

Putting a lambda in a variable
Example of a consumer
So :
Consumer<String> c = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s) ;
}
} ;
Consumer<String> c = s -> System.out.println(s) ;

So :
@Override
}
} ;
Question : what is s ?

So :
@Override
}
} ;
Answer : the compiler
infers that it is a String

So :
@Override
}
} ;
Consumer<String> c = System.out::println ;

Questions :
answer : with a functional interface
answer : yes

Is a lambda an objet ?
Let’s play the game of 7 errors (with only 1 error)
@Override
}
} ;

Questions :
answer : with a functional interface
answer : yes
answer : no

Plenty of lambdas :
java.util.function

Java.util.function
This new package holds the functional interfaces
There are 43 of them

Java.util.function
Supplier : alone in its kind
Consumer / BiConsumer
Function / BiFunction (UnaryOperator / BinaryOperator)
Predicate / BiPredicate
Plus the primitive types versions

Supplier
A supplier supplies an object
public interface Supplier<T> {
T get() ;
}

Consumer
A consumer just … accepts an object
void accept(T t) ;
}
Consumer<String> c1 = s -> System.out.println(s) ;
Consumer<String> c2 = ... ;
Consumer<String> c3 = c1.andThen(c2) ;
persons.stream().forEach(c3) ;

Function
A function takes an object and returns another one
Can be chained and / or composed
public interface Function<T, R> {
R apply(T t) ;
}

Predicate
A Predicate takes an object and returns a boolean
Can be negated, composed with and / or
boolean test(T t) ;
}

Back to the
map / filter / reduce
pattern

The JDK 7 way
How to apply map / filter / reduce
to List<Person> ?

The JDK 7 way
to List<Person> ?
The legal way is to iterate over the elements
and apply the pattern

The JDK 7 way
to List<Person> ?
The legal way is to iterate over the elements
and apply the pattern
One can create a helper method

Applying map to a List
With a helper method, JDK 7
List<Person> persons = new ArrayList<>() ;
List<Integer> ages = // ages is a new list
Lists.map(
persons,
new Mapper<Person, Integer>() {
return p.getAge() ;
}
}
) ;

With a helper method, JDK 8 & lambdas
List<Integer> ages =
Lists.map(
persons,
person -> person.getAge()
) ;

With a helper method, JDK 8 & lambdas
List<Integer> ages =
Lists.map(
persons,
Person::getAge
) ;

Putting things together
The map / filter / reduce pattern would look like this
// applying the map / filter / reduce pattern
List<Integer> ages = Lists.map( persons, p -> p.getAge()) ;
List<Integer> agesGT20 = Lists.filter(ages, a -> a > 20) ;
int sum = Lists.reduce(agesGT20, (i1, i2) -> i1 + i2) ;

The idea is to push lambdas to the API, and let it apply
them on its content

Pro : the API can be optimized
without touching the code : great !

Pro : the API can be optimized
without touching the code
Cons …

1) Suppose persons is a really BIG list

2 duplications : ages & agesGT20

2 duplications : ages & agesGT20
What do we do with them ? Send them to the GC

2) Suppose we have a allMatch() reducer
allMatch is true if all the names are shorter than 20 chars
let’s see a possible implementation of allMatch()
List<String> names =
Lists.map(persons, p -> p.getName()) ;
boolean allMatch =
Lists.allMatch(names, n -> n.length() < 20) ;

How could one write allMatch ?
Here is a basic implementation of allMatch
public static <T> boolean allMatch(
List<? extends T> list, Filter<T> filter) {
for (T t : list) {
if (!filter.filter(t)) {
return false ;
}
}
return true ;
}

How could one write allMatch ?
Here is a basic implementation of allMatch
public static <T> boolean allMatch(
List<? extends T> list, Filter<T> filter) {
for (T t : list) {
if (!filter.filter(t)) {
return false ;
}
}
return true ;
}
No need to iterate
over the whole list

When we apply the allMatch() reducer…
… the list names has already been evaluated !
boolean allMatch =
Lists.allMatch(names, n.length() < 20) ;

When we apply the allMatch() reducer…
… we should have wait to apply the filter
A good way to do that : apply the filter step lazily !
boolean allMatch =
Lists.allMatch(names, n.length() < 20) ;

Conclusion
Pro : 1
Cons : 2 (at least)

Conclusion
And the same goes for this one
List<Integer> ages = persons.map(p -> p.getAge()) ;
List<Integer> agesGT20 = ages.filter(a -> a > 20) ;
int sum = agesGT20.reduce(ages, (i1, i2) -> i1 + i2) ;

Conclusion (again)
We need a new concept to handle BIG lists efficiently

Conclusion (again)
The Collection framework is not the right one…

Conclusion (again)
The Collection framework is not the right one
We need something else !

Introduction
Putting map / filter / reduce methods on Collection
would have led to :
And even if it doesnt lead to viable patterns,
it is still a pleasant way of writing things
// map / filter / reduce pattern on collections
int sum = persons
.map(p -> p.getAge())
.filter(a -> a > 20)
.reduce(0, (a1, a2) -> a1 + a2) ;

Introduction
Let’s keep the same kind of pattern and add a stream()
int sum = persons.stream()
.reduce(0, (a1, a2) -> a1 + a2) ;

Introduction
Collection.stream() returns a Stream : new interface
New interface = our hands are free !
.reduce(0, (a1, a2) -> a1 + a2) ;

New Collection interface
So we need a new method on Collection
public interface Collection<E> {
// our good old methods
Stream<E> stream() ;
}

New Collection interface
Problem : ArrayList doesnt compile anymore…
Something has to be done !
}

Interfaces
Problem : ArrayList doesnt compile anymore…
Something has to be done !
Something that does not need to change or recompile all
the existing implementations of Collection

Java 8 interfaces
Problem : how to add methods to an interface, without
changing any of the implementations ?

Java 8 interfaces
Problem : how to add methods to an interface, without
changing any of the implementations ?
Solution : change the way interfaces work in Java

Java 8 interfaces
ArrayList needs to know the implementation of stream()…
}

Java 8 interfaces
Let’s put it in the interface !
default Stream<E> stream() {
return ... ;
}
}

Java 8 interfaces
Let’s introduce default methods in Java
Default methods are about interface evolution
Allows the extension of old interfaces
default Stream<E> stream() {
return ... ;
}
}

Default methods
Does it bring multiple inheritance to Java ?

Default methods
Yes ! But we already have it

Default methods
Yes ! But we already have it
public class String
implements Serializable, Comparable<String>, CharSequence {
// ...
}

Default methods
What we have so far is multiple inheritance of type

Default methods
What we get in Java 8 is multiple inheritance of behavior

Default methods
What we dont have is multiple inheritance of state

Default methods
What we dont have is multiple inheritance of state
… and this is where the trouble is !

Default methods
Will we have conflicts ?

Default methods
Oooh yes…

Default methods
Oooh yes…
So we need rules to handle them

Default methods
public class C
implements A, B {
// ...
}

Default methods
public interface A {
default String a() { ... }
}
public interface B {
}
Example #1
public class C
implements A, B {
// ...
}

Example #1
Compile error :
class C inherits unrelated defaults for a() from types A and B
Default methods
}
}
public class C
implements A, B {
// ...
}

Example #2
Class wins !
Default methods
}
}
public class C
implements A, B {
public String a() { ... }
}

Example #2a
I can explicitly call a default implementation
Default methods
}
}
public class C
implements A, B {
public String a() { return B.super.a() ; }
}

Example #3
More specific interfaces wins over less specific
Default methods
public interface A extends B {
}
}
public class C
implements A, B {
// ...
}

2 simple rules
To handle the conflict of multiple inheritance of behavior

2 simple rules
1) Class wins !

2 simple rules
1) Class wins !
2) More specific interfaces wins over less specific

An example
Everybody who writes an implementation of Iterator
writes this :
public class MyIterator implements Iterator<E> {
// some critical business code
public void remove() {
throw new UnsupportedOperationException("You shouldnt do that") ;
} ;
}

An example
Thanks to Java 8 :
No silly implementation of remove() anymore !
public interface Iterator<E> {
default void remove() {
throw new UnsupportedOperationException("remove") ;
} ;
}

Java 8 interfaces
So the concept of « interface » changed in Java 8
public class HelloWorld {
// souvenir souvenir
public static void main(String[] args) {
System.out.println("Hello world!") ;
} ;
}

Java 8 interfaces
So the concept of « interface » changed in Java 8
I mean, really
public interface HelloWorld {
// souvenir souvenir
public static void main(String[] args) {
System.out.println("Hello world!") ;
} ;
}

Java 8 interfaces
1) Default methods, multiple behavior inheritance
Rules to handle conflicts, solved at compile time
2) Static methods in interfaces
Will bring new patterns and new ways to write APIs

Where are we ?
1) We have a new syntax
2) We have a new pattern to implement
3) We have new interfaces to keep the backward
compatibily

What is a Stream
From a technical point of view : a typed interface
« a stream of String »

What is a Stream
From a technical point of view : a typed interface
Other classes for primitive types :
« a stream of String »
IntStream, LongStream, DoubleStream

It’s a new notion
1) A stream doesnt hold any data
It’s just an object on which one can declare operations
Streams are about « specifying computations »

It’s a new notion
2) A stream cant modify its source
Consequence : it can use parallel processing

It’s a new notion
3) A source can be infinite
So we need a way to guarantee that computations
will be conducted in finite time

It’s a new notion
3) A source can be infinite
4) A stream works lazily
Then optimizations can be made among the different
operations
We need a way / convention to trigger the computations

How can we build a stream ?
Many ways…
1) From a collection : method Collection.stream
Collection<String> collection = ... ;
Stream<String> stream = collection.stream() ;

Many ways…
2) From an array : Arrays.stream(Object [])
Stream<String> stream2 =
Arrays.stream(new String [] {"one", "two", "three"}) ;

Many ways…
2) From an array : Arrays.stream(Object [])
3) From factory methods in Stream, IntStream, …
Stream<String> stream1 = Stream.of("one", "two", "three") ;

Some more patterns
Stream.empty() ; // returns an empty Stream
Stream.of(T t) ; // a stream with a single element
Stream.generate(Supplier<T> s) ;
Stream.iterate(T seed, UnaryOperator<T> f) ;

Other ways scattered in the JDK
string.chars() ; // returns a IntStream
lineNumberReader.lines() ; // returns a Stream<String>
random.ints() ; // return a IntStream

1) Two types of operations
One can declare operations on a Stream
Two types of operations :
1) Intermediate operations : declarations, processed lazily
ex : map, filter

1) Two types of operations
One can declare operations on a Stream
Two types of operations :
1) Intermediate operations : declarations, processed lazily
ex : map, filter
2) Terminal operations : trigger the computations
ex : reduce

A 1st example
Back to our map / filter / reduce example
.reduce(0, (a1, a2) -> a1 + a2) ;
Build a stream
on a List

A 1st example
.reduce(0, (a1, a2) -> a1 + a2) ;
Declare
operations

A 1st example
.reduce(0, (a1, a2) -> a1 + a2) ;
Triggers the
computation

2) State of a stream
The implementation of Stream has a state :
- SIZED : the number of elements is known
- ORDERED : the order matters (List)
- DISTINCT : all elements are unique (Set)
- SORTED : all elements have been sorted (SortedSet)

Some operations change that :
- filtering removes the SIZED
- mapping removes DISTINCT and SORTED

And it allows nice optimizations !
- a HashSet cant have doubles so…

- distinct() is NOPed on a stream built on a HashSet

- A TreeSet is sorted so…

- A TreeSet is sorted so…
- sorted() is NOPed on a stream built on a TreeSet

3) Stateless / stateful operations
Stateless / stateful operations
Some operations are stateless :
It means that they dont need more information than the
one held by their parameters
persons.stream().map(p -> p.getAge()) ;

3) Stateless / stateful operations
Stateless / stateful operations
Some operations are stateless :
Some need to retain information :
persons.stream().map(p -> p.getAge()) ;
stream.limit(10_000_000) ; // select the 10M first elements

Example
Let’s sort an array of String
Random rand = new Random() ;
String [] strings = new String[10_000_000] ;
for (int i = 0 ; i < strings.length ; i++) {
strings[i] = Long.toHexString(rand.nextLong()) ;
}

Example
Soooo Java 7…
String [] strings = new String[10_000_000] ;
for (int i = 0 ; i < strings.length ; i++) {
strings[i] = Long.toHexString(rand.nextLong()) ;
}

Example
Better ?
Stream<String> stream =
Stream.generate(
() ->
Long.toHexString(rand.nextLong())
) ;

Example
Better !
// Random rand = new Random() ;
Stream.generate(
() ->
Long.toHexString(ThreadLocalRandom.current().nextLong())
) ;

Example
// other way
ThreadLocalRandom
.current()
.longs() // returns a LongStream
.mapToObj(l -> Long.toHexString(l)) ;

Example
// other way
ThreadLocalRandom
.current()
.longs()
.mapToObj(Long::toHexString) ;

Example
// other way
ThreadLocalRandom
.current()
.longs()
.mapToObj(Long::toHexString)
.limit(10_000_000)
.sorted() ;
T = 4 ms

Example
// other way
ThreadLocalRandom
.current()
.longs()
.limit(10_000_000)
.sorted() ;
Object [] sorted = stream.toArray() ;

Example
// other way
ThreadLocalRandom
.current()
.longs()
.limit(10_000_000)
.sorted() ;
T = 14 s

Example
// other way
ThreadLocalRandom
.current()
.longs()
.limit(10_000_000)
.sorted() ;
T = 14 s
Intermediate calls !

Last word about stream operations
1) There are intermediate and terminal operations
2) A stream is processed on a terminal operation call

Last word about stream operations
1) There are intermediate and terminal operations
2) A stream is processed on a terminal operation call
3) Only one terminal operation is allowed
4) It cannot be processed again
If needed another stream should be built on the source

Optimization
The first optimization (well, laziness was first !) we need is
parallelism
The fork / join enable parallel programming since JDK 7
But writing tasks is hard and does not always lead to better
performances

Optimization
The first optimization (well, laziness was first !) we need is
parallelism
The fork / join enable parallel programming since JDK 7
But writing tasks is hard and does not always lead to better
performances
Using the parallel stream API is much more secure

How to build a parallel stream ?
Two patterns
1) Call parallelStream() instead of stream()
2) Call parallel() on an existing stream
Stream<String> s = strings.parallelStream() ;
Stream<String> s = strings.stream().parallel() ;

Is parallelism really that simple ?
Well… yes !

Well… yes !
… and no

Example 1 :
« returns the 10M first elements of the source »
persons.stream().limit(10_000_000) ;

Example 1 :
« returns the 10M first elements of the source »
persons.parallelStream().limit(10_000_000) ;

Example 1 : performances
Code 1
List<Long> list = new ArrayList<>(10_000_100) ;
for (int i = 0 ; i < 10_000_000 ; i++) {
list1.add(ThreadLocalRandom.current().nextLong()) ;
}

Code 2
Stream<Long> stream =
Stream.generate(() -> ThreadLocalRandom.current().nextLong()) ;
List<Long> list1 =
stream.limit(10_000_000).collect(Collectors.toList()) ;

Code 3
Stream<Long> stream =
ThreadLocalRandom.current().longs(10_000_000).mapToObj(Long::new) ;
List<Long> list = stream.collect(Collectors.toList()) ;

Serial Parallel
Code 1 (for) 270 ms
Code 2 (limit) 310 ms
Code 3 (longs) 250 ms

Serial Parallel
Code 1 (for) 270 ms
Code 2 (limit) 310 ms 500 ms
Code 3 (longs) 250 ms 320 ms

Example 2 :
« returns a stream with all the elements of the first stream
followed by all the elements of the second stream »
Stream s3 = Stream.concat(stream1, stream2) ;

Parallelism
Parallelism implies overhead most of the time
Badly configured parallel operations can lead to unneeded
computations that will slow down the overall process
Unnecessary ordering of a stream will lead to performance
hits

A simple reduction
Sum of ages
.reduce(0, (a1, a2) -> a1 + a2) ;

A simple reduction
It would be nice to be able to write :
But there’s no sum() on Stream<T>
What would be the sense of « adding persons » ?
.sum() ;

A simple reduction
It would be nice to be able to write :
But there’s no sum() on Stream<T>
There’s one on IntStream !
.sum() ;

A simple reduction
2nd version :
Value if persons is an empty list : 0
.map(Person::getAge)
.mapToInt(Integer::intValue)
.sum() ;

A simple reduction
2nd version (even better) :
Value if persons is an empty list : 0
.mapToInt(Person::getAge)
// .mapToInt(Integer::intValue)
.sum() ;

A simple reduction
What about max() and min() ?
How can one chose a default value ?
....... = persons.stream()
.max() ;

Problem with the default value
The « default value » is a tricky notion

1) The « default value » is the reduction of the empty set

1) The « default value » is the reduction of the empty set
2) But it’s also the identity element for the reduction

Problem : max() and min() have no identity element
eg : an element e for which max(e, a) = a

Problem : max() and min() have no identity element
eg : an element e for which max(e, a) = a
0 cant be, max(0, -1) is not -1…
−∞ is not an integer

So what is the identity element of max() and min() ?

So what is the identity element of max() and min() ?
Answer : there is no identity element for max() or min()

So what is the default value of max() and min() ?

So what is the default value of max() and min() ?
Answer : there is no default value for max() and min()

So what is the returned value of the max() reduction ?
.max() ;

If it’s int, then the default value will be 0…
.max() ;

If it’s int, then the default value will be 0…
It it’s Integer, then the default value will be null…
.max() ;

Optionals
Since there’s none, we need another notion
OptionalInt optionalMax = persons.stream()
.max() ;
« there might be no
result »

Optionals
What can I do with OptionalInt ?
1st pattern : test if it holds a value
OptionalInt optionalMax = ... ;
int max ;
if (optionalMax.isPresent()) {
max = optionalMax.get() ;
} else {
max = ... ; // decide a « default value »
}

Optionals
1st pattern bis : read the held value, giving a default value
// get 0 if no held value
int max = optionalMax.orElse(0) ;

Optionals
2nd pattern : read the held value, can get an exception
// throws NoSuchElementException if no held value
int max = optionalMax.getAsInt() ;

Optionals
2nd pattern bis : read the held value, or throw an exception
// exceptionSupplier will supply an exception, if no held value
int max = optionalMax.orElseThrow(exceptionSupplier) ;

Available optionals
Optional<T>
OptionalInt, OptionalLong, OptionalDouble

Available reductions
On Stream<T> :
- reduce(), with different parameters
- count(), min(), max()
- anyMatch(), allMatch(), noneMatch()
- findFirst(), findAny()
- toArray()
- forEach(), forEachOrdered()

Available reductions
On IntStream, LongStream, DoubleStream :
- average()
- summaryStatistics()

Mutable reductions : example 1
Use of the helper class : Collectors
ArrayList<String> strings =
stream
.map(Object::toString)
.collect(Collectors.toList()) ;

Concatenating strings with a helper
String names = persons
.stream()
.map(Person::getName)
.collect(Collectors.joining()) ;

Mutable reductions
Common things :
- have a container : Collection or StringBuilder
- have a way to add an element to the container
- have a way to merge two containers (for parallelization)

Putting things together :
stream
.collect(
() -> new ArrayList<String>(), // the supplier
(suppliedList, s) -> suppliedList.add(s), // the accumulator
(supplied1, supplied2) -> supplied1.addAll(supplied2) // the combiner
) ;

stream
.collect(
ArrayList::new, // the supplier
ArrayList::add, // the accumulator
ArrayList::addAll // the combiner
) ;

stream
.collect(
ArrayList::new, // the supplier
ArrayList::add, // the accumulator
ArrayList::addAll // the combiner
) ;
stream
.collect(Collectors.toList()) ;

The Collectors class
A rich toolbox (37 methods) for various types of reductions
- counting, minBy, maxBy
- summing, averaging, summarizing
- joining
- toList, toSet
And
- mapping, groupingBy, partionningBy

Average, Sum, Count
persons
.stream()
.collect(Collectors.averagingDouble(Person::getAge)) ;
persons
.stream()
.collect(Collectors.counting()) ;

Concatenating the names in a String
String names = persons
.stream()
.map(Person::getName)
.collect(Collectors.joining(", ")) ;

Accumulating in a List, Set
Set<Person> setOfPersons = persons
.stream()
.collect(
Collectors.toSet()) ;

Accumulating in a custom collection
TreeSet<Person> treeSetOfPersons = persons
.stream()
.collect(
Collectors.toCollection(TreeSet::new)) ;

Getting the max according to a comparator
Bonus : new API to build comparators
Optional<Person> optionalPerson = persons
.stream()
.collect(
Collectors.maxBy(
Comparator.comparing(Person::getAge)) ;

Building comparators
New API to build comparators in a declarative way
Comparator<Person> comp =
Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparing(Person:getAge) ;

Other examples
Interface Predicate
Predicate<Long> p1 = i -> i > 20 ;
Predicate<Long> p2 = i -> i < 50 ;
Predicate<Long> p3 = p1.and(p2) ;
Person stephan = ... ;
Predicate<Person> p = Predicat.isEqual(stephan) ;

The Collector API : groupingBy
« Grouping by » builds hash maps
- must explain how the keys are built
- by default the values are put in a list
- may specify a downstream (ie a collector)

Grouping a list of persons by their age
Map<Integer, List<Person>> map =
persons
.stream()
.collect(
Collectors.groupingBy(Person::getAge)) ;

Grouping a list of persons by their age
Map<Integer, Set<Person>> map =
persons
.stream()
.collect(
Collectors.groupingBy(
Person::getAge,
Collectors.toSet() // the downstream
) ;

Grouping a list of persons names by their age
Map<Integer, Set<String>> map =
persons
.stream()
.collect(
Person::getAge,
Collectors.mapping( //
Person::getLastName, // the downstream
Collectors.toSet() //
)
) ;

Grouping a list of persons names by their age
Map<Integer, TreeSet<String>> map =
persons
.stream()
.collect(
Person::getAge,
Collectors.mapping(
Person::getLastName,
Collectors.toCollection(TreeSet::new)
)
) ;

Grouping a list of blah blah blah
TreeMap<Integer, TreeSet<String>> map =
persons
.stream()
.collect(
Person::getAge,
TreeMap::new,
Collectors.mapping(
Collectors.toCollection(TreeSet::new)
)
) ;

Example : creating an age histogram
Gives the # of persons by age
Map<Integer, Long> map =
persons
.stream()
.collect(
Collectors.groupingBy(Person::getAge, Collectors.counting())
) ;

The Collectors class : mapping
The mapping helper method takes 2 parameter :
- a function, that maps the elements of the stream
- a collector, called a « downstream », that is applied to
the mapped values

Accumulating names in a set
Set<String> set = persons
.stream()
.collect(
Collectors.mapping(
Collectors.toSet())) ;

Mapping the stream, then accumulating in a collection
TreeSet<String> set = persons
.stream()
.collect(
Collectors.mapping(
Collectors.toCollection(TreeSet::new))
) ;

The Collector API : partioningBy
Creates a Map<Boolean, …> on a predicate
- the map has 2 keys : TRUE and FALSE
- may specify a downstream

Creates a Map<Boolean, …> on a predicate
map.get(TRUE) returns the list people older than 20
Map<Boolean, List<Person>> map =
persons
.stream()
.collect(
Collectors.partitioningBy(p -> p.getAge() > 20)
) ;

Can further process the list of persons
Map<Boolean, TreeSet<String>> map =
persons
.stream()
.collect(
Collectors.partitioningBy(
p -> p.getAge() > 20,
Collectors.mapping(
)
)
) ;

persons
.stream()
.collect(
p -> p.getAge() > 20,
Collectors.mapping(
)
)
) ;
Partition the persons
on age > 20

persons
.stream()
.collect(
p -> p.getAge() > 20,
Collectors.mapping(
)
)
) ;
Gather their names…

persons
.stream()
.collect(
p -> p.getAge() > 20,
Collectors.mapping(
)
)
) ;
… in TreeSets

The Collector API : collectingAndThen
Collect data with a downstream
Then apply a function called a « finisher »
Useful for putting the result in a immutable collection

The Collector API : collectingAndThen
In this case « Map::entrySet » is a finisher
Set<Map.Entry<Integer, List<Person>>> set =
persons
.stream()
.collect(
Collectors.collectingAndThen(
Person::getAge), // downstream, builds a map
Map::entrySet // finisher, applied on the map
) ;

1st example
Optional<Entry<Integer, Long>> opt =
movies.stream().parallel()
.collect(
movie -> movie.releaseYear(),
Collectors.counting()
),
Map::entrySet
)
)
.stream()
.max(Map.Entry.comparingByValue()) ;

1st example
.collect(
),
Map::entrySet
)
)
.stream()
A Stream of movies

1st example
.collect(
),
Map::entrySet
)
)
.stream()
Building a map
of year / # of movies

1st example
.collect(
),
Map::entrySet
)
)
.stream()
Then getting the
entry set

1st example
.collect(
),
Map::entrySet
)
)
.stream()
Then getting the
max by value

1st example
.collect(
),
Map::entrySet
)
)
.stream()
Returns the
year with the most
movies released

Conclusion
Why are lambdas introduced in Java 8 ?

Conclusion
Because it’s in the mood !

Java 8 Streams & Collectors : the Leuven edition

Conclusion
Because it’s in the mood !
Because it allows to write more compact code !

Compact code is better !
An example of compact code (in C)
#include "stdio.h"
main() {
int b=0,c=0,q=60,_=q;for(float i=-20,o,O=0,l=0,j,p;j=O*O,p=l*l,
(!_--|(j+p>4)?fputc(b?q+(_/3):10,(i+=!b,p=j=O=l=0,c++,stdout)),
_=q:l=2*O*l+i/20,O=j-p+o),b=c%q,c<2400;o=-2+b*.05) ;
}
http://www.codeproject.com/Articles/2228/Obfuscating-your-Mandelbrot-code

Compact code is better !
An example of compact code (in C)
#include "stdio.h"
main() {
int b=0,c=0,q=60,_=q;for(float i=-20,o,O=0,l=0,j,p;j=O*O,p=l*l,
(!_--|(j+p>4)?fputc(b?q+(_/3):10,(i+=!b,p=j=O=l=0,c++,stdout)),
_=q:l=2*O*l+i/20,O=j-p+o),b=c%q,c<2400;o=-2+b*.05) ;
}
http://www.codeproject.com/Articles/2228/Obfuscating-your-Mandelbrot-code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++ ++ +++++++++++
+++++++++++++++++++++++++++++++++++ +++++++
++++++++++++++++++++++++++++++++++++ +++++++
+++++++++++++++++++++++++++++++++++ ++++++++
++++++++++++++++++++++++++++++++++ +++++++
+++++++++++++++++++++++++++++++++ +++++
+++++++++++++++++++++++++++++++++ ++++++
+++++++++++++++++++++++ + +++++ ++++++
+++++++++++++++++++++++ ++ ++++++
++++++++++++++++++++++ + ++++++
++++++++++++++++++++++ + ++++++
++++++++++++++++++++ + + +++++++
++++++ ++++++++
++++++++++++++++++++ + + +++++++
++++++++++++++++++++++ + ++++++
++++++++++++++++++++++ + ++++++
+++++++++++++++++++++++ ++ ++++++
+++++++++++++++++++++++ + +++++ ++++++
+++++++++++++++++++++++++++++++++ ++++++
+++++++++++++++++++++++++++++++++ +++++
++++++++++++++++++++++++++++++++++ +++++++
+++++++++++++++++++++++++++++++++++ ++++++++
++++++++++++++++++++++++++++++++++++ +++++++
+++++++++++++++++++++++++++++++++++ +++++++
++++++++++++++++++++++++++++++++++++ ++ +++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Conclusion
Because it brings new and efficient patterns,
that enable easy and safe parallelization,
- needed by modern applications
- needed by API writers

Conclusion
Java 8 is coming, it’s the biggest update in 15 years

Conclusion
Moving to Java 8 means a lot of work for us developers !
- Self training
- Changing our habits

Conclusion
Moving to Java 8 means a lot of work for us developers !
- Self training
- Changing our habits
- Convincing our bosses (sigh…)

Conclusion
Release date : 18th march 2014 !

Conclusion
« Java is a blue collar language. It’s not PhD thesis
material but a language for a job » – James Gosling, 1997

Conclusion
« Language features are not a goal unto themselves;
language features are enablers, encouraging or
discouraging certain styles and idioms » – Brian Goetz,
2013

Conclusion
The good news is :
Java is still Java !

Java 8 Streams & Collectors : the Leuven edition

More Related Content

What's hot (20)

Similar to Java 8 Streams & Collectors : the Leuven edition (20)

More from José Paumard (16)

Recently uploaded (20)

Java 8 Streams & Collectors : the Leuven edition