Lambda/Streams Hands-On Lab

Lambda Masterclass, JavaDay.ro, December 2018
Lambda Programming Laboratory
A Masterclass for Java Developers
JavaDay.ro 2019
Maurice Naftalin
@mauricenaftalin

• Intro + Setup
• Lambdas and Method References
• Comparators
• Default Methods
• Streams I
• Streams II
Agenda

Maurice Naftalin

Maurice Naftalin
Java 5

Maurice Naftalin
Java 5 Java 8

Maurice Naftalin
Java 5 Java 8
2013

Maurice Naftalin
Java 5 Java 8
2014

Maurice Naftalin
Java 5 Java 8
2015

Open https://github.com/mauricen/LambdaHOLv2/
Select Branch: Java 8 or Java 9
Click "Clone or download"; choose "Download ZIP"  
– save to local disk, expand
Setup 1

Setup 2
IntelliJ IDEA
Select New | Project from Existing Sources; select the
new directory LambdaHOLv2-Java8/9, click Open,
then Import project from external model, select
Maven; click Next, Next, and Finish
Check that the module SDK (set from File | Project
Structure… | Modules, Dependencies tab) and the
language level (Sources tab) are set correctly.
Labs are in the package exercises.otherides,
under the directory LambdaLab/test. Detailed lab
instructions are in the README.
Eclipse
Select Preferences | Java | Editor | Folding,
ensure Comments checkbox is ticked.
Select File | Import… | Maven | Existing Maven
Projects, click Next, select new directory
LambdaHOL-v2-Java8/9, click Finish
Labs are in the package exercises.eclipse,
under the directory LambdaLab/test. Detailed
lab instructions are in the README.

Lambdas–taking values to a higher order

public interface Collection<E> {
...
boolean removeAll(Collection<?> c);
...
}
instead of supplying values to
speciﬁc library methods

...
...
}
...
boolean removeIf(Predicate<? super E> p);
...
}
we want to supply behaviour to
general library methods:

Predicate is an interface with a single abstract boolean-valued method test.
The method removeIf executes test for each element, and –
...
...
}
...
...
}

Predicate is an interface with a single abstract boolean-valued method test.
The method removeIf executes test for each element, and –
• if test returns true, removeIf removes that element
...
...
}
...
...
}

How can an instance of an interface represent behaviour?
A behaviour is implemented by a single method!
Predicate is an Interface

Convention: if an interface has a single abstract method, like Predicate:
then when the behaviour of an instance of the interface is wanted, the
behaviour of that single method is used.
public interface java.util.functions.Predicate<T> {
boolean test(T t);
}

Convention: if an interface has a single abstract method, like Predicate:
then when the behaviour of an instance of the interface is wanted, the
behaviour of that single method is used.
public interface java.util.functions.Predicate<T> {
boolean test(T t);
}
Functional Interface

How to make an Interface Instance?

The old way was using an anonymous inner class: 
 
 
// Predicate returns true for odd values of i
new Predicate<Integer>(){
public boolean test(Integer i) {
return i & 1 == 1;
});

The old way was using an anonymous inner class: 
 
 
and we can still supply that as a method argument:
// Predicate returns true for odd values of i
new Predicate<Integer>(){
return i & 1 == 1;
});
// remove odd values from integerList
integerList.removeIf(new Predicate<Integer>(){
return i & 1 == 1;
}));

Stripping Out the Boilerplate

// remove odd numbers from integerList
return (i & 1) == 1;
}
});

return (i & 1) == 1;
}
});
Why do we have to say we’re supplying a Predicate?

return (i & 1) == 1;
}
});

return (i & 1) == 1;
}
});
Why do we have to say we’re implementing test, the only abstract method?

return (i & 1) == 1;
}
});
Why do we have to say the type parameter is Integer?

integerList.removeIf(i (i & 1) == 1)

integerList.removeIf(i (i & 1) == 1)
All we need is one extra syntax element!

integerList.removeIf(i -> (i & 1) == 1)

Rules for Writing Lambdas

() -> 42

() -> 42
a -> a + 1 // single untyped parameter – can omit parentheses

() -> 42
(a,b) -> a + b // but they are needed for multiple parameters

() -> 42
(int a, int b) -> a + b; 
// type either all parameters, or none

() -> 42
(int a, int b) -> a + b; 
// type either all parameters, or none
() -> { println(42); return 42; }  
// lambda body can be a statement

Target Typing
Context is needed to deﬁne a lambda’s type:

Target Typing
Runnable r = () -> {} // compiles

Target Typing
Thread t = new Thread(() -> {}) // compiles

Target Typing
Thread t = new Thread(() -> {}) // compiles
Object o = () -> {} // illegal

Method References
Sometimes it’s more convenient to write lambdas as
method references. There are four kinds:
example lambda equivalent
constructor ArrayList::new () -> new ArrayList()
static Integer::max (x,y) -> Integer.max(x,y)
bound “abc"::concat str -> "abc".concat(str)
unbound String::length str -> str.length()

Lambdas and Method References
Demo and labs

Comparator
Comparators were enhanced with static and default
methods in Java 8. Now, instead of writing this:
Comparator<Person> cmpr = new Comparator<>() {
@Override
public int compare(Person p1, Person p2) {
int cmp = p1.getLastName().compareTo(p2.getLastName());
if (cmp == 0) {
return p1.getFirstName().compareTo(p2.getFirstName());
} else {
return cmp;
}
}
};

Comparator
We can instead write
using default and factory methods on Comparator
Comparator<Person> cmp =
Comparator.comparing(Person::getLastName)
.thenComparing(Person::getFirstName)
.thenComparing(Person::getAge);

Comparator Methods returning Comparator<T>
name argument(s)
static comparing Function<T,U>
comparing Function<T,U>, Comparator
comparingXxx ToXxxFunction<T>
naturalOrder
nullsFirst/Last Comparator<T>
reverseOrder Comparator<T>
default reversed
thenComparing Comparator<T>
thenComparingXxx ToXxxFunction<T>

Example Domain
ﬁrstName: String
lastName: String
age: int
Person

Comparators
Demo and labs

• Intro + Setup
• Lambdas and Method References
• Comparators
• Default Methods
• Streams 1
• Streams II
Agenda

Iterable<T>
forEach(Consumer<T> c)
supplies each element in turn to c
removeIf(Predicate<T> p)
removes elements satisfying p
compute(K key, BiFunction<K,V,V> remappingFunction)
computes a new mapping from key and its current mapped value (or null)
computeIfAbsent(K key, Function<K,V> mfn)
if there is no current mapping for key, creates one using mfn and enters it
computeIfPresent(K key, BiFunction<K,V,V> remappingFunction)
creates a mapping from key (if present and non-null) and its current mapped value
forEach(BiConsumer<K,V> c)
executes c for each key-value pair in this Map
merge(K key, V v, BiFunction<V,V,V> remappingFunction)
if key present, calculates new value from old value and v, o.w. associates key with v
putIfAbsent(K key, V value)
associates key with value if key is not present or is null
remove(Object k, Object val)
removes mapping for k from this map if it is present and has the value val
replace(K key, V oldValue, V newValue)
replaces the entry for key only if currently mapped to oldvalue
replaceAll(BiFunction<K,V,V> fn)
replaces each entry’s value with the result of applying fn to the entry’s key and value
replaceAll(UnaryOperator<E> op)
replaces each element with the result of applying op to it
Map<K,V>
List<E>

Default Methods on Map
returns name argument(s)
void forEach BiConsumer<K,V>
void replaceAll BiFunction<K,V,V>
V computeIfAbsent K, Function<K,V>
V computeIfPresent K, BiFunction<K,V,V>
V compute K, BiFunction<K,V,V>
V merge K, V, BiFunction<K,V,V>
boolean remove Object, Object
V replace K, V
boolean replace K, V, V
V putIfAbsent K, V

Default Methods
Demo and labs

x0 x1 x2 x3
Visualizing Stream Operations

x0x1 x2 x3

y0x1 x2 x3

x1 x2 x3

x1x2 x3

y1x2 x3

x2 x3

x2
x0
x1
x3
33
x0
x1
x2
x3

x2
y0
y1
y2
y3
33
x0
x1
x3

x2
33
x0
x1
x3

name returns interface used FI signature
ﬁlter Stream<T> Predicate<T> T ➞ boolean
map Stream Function<T,U> T ➞ U
ﬂatMap Stream<R> Function<T,Stream<R>> T ➞ Stream<R>
peek Stream<T> Consumer<T> T ➞ void
Stateless Intermediate Operations
34

name returns interface used FI signature
ﬁlter Stream<T> Predicate<T> T ➞ boolean
map Stream Function<T,U> T ➞ U
ﬂatMap Stream<R> Function<T,Stream<R>> T ➞ Stream<R>
peek Stream<T> Consumer<T> T ➞ void
Stateless Intermediate Operations
34
mapToInt IntStream ToIntFunction<T> T ➞ int
mapToLong LongStream ToLongFunction<T> T ➞ long
mapToDouble DoubleStream ToDoubleFunction<T> T ➞ double

filter()
filter(s -> s.length() < 4)
Stream<String>
Predicate<String
Stream<String>
filter()

ﬁlter()
Stream<String>
Predicate<String
Stream<String>
ﬁlter()
“jim”
✔

ﬁlter()
Stream<String>
Predicate<String
Stream<String>
ﬁlter()
✔

ﬁlter()
✖
Stream<String>
Predicate<String
Stream<String>
ﬁlter()
✔

ﬁlter()
✖
Stream<String>
Predicate<String
Stream<String>
ﬁlter()
✔
“amy”

map()
map(Person::getCity)
Stream<Person> Stream<City>
Function<Person,City

map()
bill

map()
amy

peek()
peek(System.out::println)
Consumer<T>
System.out::println
T
Stream<T>

ﬂatMapToInt()
Stream<String>
Function<String,IntStream>
IntStream
flatMapToInt(String::chars)

ﬂatMapToInt()
Stream<String>
IntStream
'a' 'm' 'y'

ﬂatMapToInt()
Stream<String>
IntStream
'm' 'y'

ﬂatMapToInt()
Stream<String>
IntStream
'y'

name returns type used FI signature
limit Stream<T> long
skip Stream<T> long
sorted Stream<T> Comparator<T> (T, T) ➞ int
distinct Stream<T>
takeWhile* Stream<T> Predicate<T>
dropWhile* Stream<T> Predicate<T>
Stateful Intermediate Operations
* added in Java 9

Collectors: Journey’s End for a Stream
The Life of a Stream Element
• Born (at a spliterator)
• Transformed (by intermediate operations)
• Collected (by a terminal operation)

Collectors: Journey’s End for a Stream
?
The Life of a Stream Element
• Born (at a spliterator)
• Transformed (by intermediate operations)
• Collected (by a terminal operation)

Terminal Operations
– Search operations
– Side-effecting operations
– Reductions

Search Operations
Search operations -
• allMatch, anyMatch
• ﬁndAny, ﬁndFirst
boolean allAdults =
people.stream() 
.allMatch(p -> p.getAge() >= 21);

Side-effecting Operations
Side-effecting operations
• forEach, forEachOrdered 
 
people.stream() 
.forEach(System.out::println);
• So could we calculate total ages like this? 
 
int sum = 0; 
people.stream() 
.mapToInt(Person::getAge) 
.forEach(a -> { sum += a });
people.stream() 
.forEach(System.out::println); 
int sum = 0; 
people.stream() 
.forEach(a -> { sum += a; });

Side-effecting Operations
Side-effecting operations
• forEach, forEachOrdered 
 
people.stream() 
.forEach(System.out::println);
• So could we calculate total ages like this? 
 
int sum = 0; 
people.stream() 
.forEach(a -> { sum += a });
people.stream() 
.forEach(System.out::println); 
int sum = 0; 
people.stream() 
.forEach(a -> { sum += a; }); 
Don’t do this!

• Using an accumulator:
Reduction – Why?
int[] vals = new int[100];
Arrays.setAll(vals, i -> i);
int sum = 0;
for (int i = 0 ; i < vals.length ; i++) {
sum += vals[i];
}

• Using an accumulator:
Reduction – Why?
int sum = 0;
for (int i = 0 ; i < vals.length ; i++) {
sum += vals[i];
} 
0 1 2 3
+
+
+

• Avoiding an accumulator:
Reduction – Why?

Reduction – Why?
OptionalInt sum = Arrays.stream(vals)
.reduce((a,b) -> a + b); 
+ +
+
1 2 30

Reduction – Why?
+ +
+
1 2 30
+
+
+

Reduction – Why?
BinaryOperator must be associative!
+ +
+
1 2 30
+
+
+

Reduction – Why?
BinaryOperator must be associative!
a + (b + c) = (a + b) + c
+ +
+
1 2 30
+
+
+

0 1 2 3 4 5 6 7
+ +
+
+
+
+
+
Reduction – Why?

0 1 2 3 4 5 6 7
+ +
+
+
+
+
+
Intermediate operations
Reduction – Why?

Reduction on ImmutableValues
Reduction works on immutable values too
BigDecimal[] vals = new BigDecimal[100];
Arrays.setAll(vals, i -> new BigDecimal(i));
Optional<BigDecimal> sum = Arrays.stream(vals)
.reduce(BigDecimal::add);

Streams 1
Demo and labs

What about Collections?

This also works with immutable values.

And even collections – sort of … but then
• for each element, client code has to create a new empty
collection and add the single element to it,
• and combine collections using addAll

And even collections – sort of … but then
• for each element, client code has to create a new empty
collection and add the single element to it,
• and combine collections using addAll
... it’s hopelessly inefﬁcient!

But collections need to

• be initialised

• be initialised
• have individual elements added

• be initialised
• have individual elements added
• be merged

A better idea  
would be

A better idea  
would be
Reduction over an Identity

BigDecimal[] vals = new BigDecimal[100];
Arrays.setAll(vals, i -> new BigDecimal(i));
BigDecimal sum = Arrays.stream(vals)
.reduce(BigDecimal.ZERO, BigDecimal::add); 
Works for primitives (of course) and also immutable objects:

+
+
+
0 1 2 3
+
+
+
0
4 5 6 7
0
++
+

So, Reduction to Collections?

Reduction over an identity doesn’t work with
collections at all

collections at all
• reduction reuses the identity element

collections at all
• reduction reuses the identity element
We need something better!

The Answer – Collectors
a
a
a
e0 e1 e2 e3
a
a
a
e4 e5 e6 e7
aa
c

a
a
a
e0 e1 e2 e3
a
a
a
() -> []
e4 e5 e6 e7
aa
c
() -> []

a
a
a
e0 e1 e2 e3
a
a
a
() -> []
e4 e5 e6 e7
aa
c
a: accumulator
c: combiner
() -> []

Collectors

So to deﬁne a collector, you need to provide
• Supplier
• Accumulator
• Combiner
Collectors

• Supplier
• Accumulator
• Combiner
That sounds really hard…
Collectors

• Supplier
• Accumulator
• Combiner
That sounds really hard…
Good then that we don’t have to do it!
Collectors

Example Domain
city: City
name: String
age: int
Person
Person amy = new Person(Athens, "Amy", 21); 
...
List<Person> people = Arrays.asList(jon, amy, bill);

• Why collectors?
• Using the predeﬁned collectors
• Worked problems 
Journey’s End – Agenda

Using the Predeﬁned Collectors
Predeﬁned Standalone Collectors – from factory
methods in Collectors class
• toList(), toSet(), toMap(), joining()
• toMap(), toCollection()
• groupingBy(), partitioningBy(),
groupingByConcurrent()

framework provides
the Supplier

user provides
the Supplier
framework provides
the Supplier

user provides
the Supplier
produce a  
classiﬁcation map
framework provides
the Supplier

Simple Collector – toSet()

people.stream().collect(Collectors.toSet())

Collectors.toSet()

Stream<Person>
Collectors.toSet()
Set<Person>
Collector<Person,?,Set<Person>>

Stream<Person>
Collectors.toSet()
Set<Person>
bill

Stream<Person>
Collectors.toSet()
Set<Person>
bill
jon

Stream<Person>
Collectors.toSet()
Set<Person>
amy
bill
jon

Collectors.toSet()
Set<Person>
amy
bill
jon

Collectors.toSet()
Set<Person>
{ , , }
amybilljon

toMap(Function<T,K> keyMapper,
Function<T,U> valueMapper)
people.stream().collect(
Collectors.toMap(
Person::getCity, 
Person::getName))

Stream<Person>
toMap() Map<City,String>
Collector<Person,?,Map<City,String>
people.stream().collect(toMap(Person::getCity,Person::getName))

Stream<Person>
Collector<Person,?,Map<City,String>

Stream<Person>
bill

Stream<Person>
bill
Person::getCity

Stream<Person>
London
bill

Stream<Person>
London
bill Person::getName

Stream<Person>
London “Bill”
bill Person::getName

Stream<Person>
London “Bill”

Stream<Person>
amy
London “Bill”

Stream<Person>
Athens
amy
London “Bill”

Stream<Person>
“Amy”Athens
London “Bill”

Stream<Person>
“Amy”Athens
jon
London “Bill”

Stream<Person>
“Amy”Athens
London “Bill”
Tulsa “Jon”

“Amy”Athens
London “Bill”
Tulsa “Jon”

Stream<Person>

Stream<Person>
“Amy”Athens
jon
London “Bill”
Athens

Stream<Person>
“Amy”Athens
jon
London
IllegalStateException
“Bill”
Athens

Function<T,U> valueMapper
BinaryOperator mergeFunction)
Collectors.toMap(
Person::getCity, 
Person::getName,
(a,b) -> a.concat(b)))

Stream<Person>

Stream<Person>
“Amy”Athens
London “Bill”
“Jon”
Athens

Stream<Person>
“Amy”Athens
London “Bill”
“Jon”
(a,b) -> a.concat(b)
Athens

Stream<Person>
Athens
London “Bill”
(a,b) -> a.concat(b)
“AmyJon”
Athens

Collectors API
Factory methods in the Collectors class.They
produce standalone collectors, accumulating to:
• framework-supplied containers
• custom collections
• classiﬁcation maps

BinaryOperator mergeFunction,
Supplier<M> mapFactory)
Collectors.toMap(
Person::getCity, 
Person::getName,
(a,b) -> a.concat(b), 
TreeMap::new))

BinaryOperator mergeFunction,
Supplier<M> mapFactory)
Stream<Person>

Collecting to Custom Collections

toCollection(Supplier<C> collectionFactory)

returns
Collector<T,?,C>

returns
Collector<T,?,C>
NavigableSet<String> sortedNames = people.stream()
.map(Person::getName) 
.collect(toCollection(TreeSet::new));

Collecting to Classiﬁcation Maps
groupingBy
• simple
• with downstream
• with downstream and map factory
partitioningBy

groupingBy(Function<T,K> classifier)
Uses the classifier function to make a classification mapping
Like toMap(), except that the values placed in the map are lists of
the elements, one List corresponding to each classification key:
For example, use Person.getCity() to make a Map<City,List<Person>>
Map<City,List<Person>> peopleByCity = people.stream()
.collect(Collectors.groupingBy(Person::getCity));

Stream<Person>
groupingBy() Map<City,List<Person>>
bill
jon
amy Athens
London
Collector<Person,?,Map<City,List<Person>
groupingBy(Function<Person,City>)
Classiﬁer
Person→City

Stream<Person>
bill
jon
amy Athens
London

Stream<Person>
bill
jon
amy Athens
bill London

Stream<Person>
bill
jon
amy Athens
billLondon
[ ]

Stream<Person>
bill
jon
amy Athens [ ]
bill
amy
London
[ ]

Stream<Person>
bill
jon
amy Athens [ ]
[ , ]bill
amy
jonLondon

bill
jon
amy Athens [ ]
[ , ]bill
amy
jonLondon

bill
jon
amy
Athens [ ]
[ , ]bill
amy
jonLondon

groupingBy(classifier, downstream)
Uses the classifier function to make a classification mapping into a
container defined by a downstream Collector
Like toMap(), except that the values placed in the map are containers
of the elements, one container corresponding to each classification key:
For example, use Person.getCity() to make a Map<City,Set<Person>>
Map<City,Set<Person>> peopleByCity = people.stream()
.collect(Collectors.groupingBy(Person::getCity,toSet()));

groupingBy(Function classifier,Collector downstream))
Stream<Person>
groupingBy()
Map<City,Set<Person>
bill
jon
amy
London
Athens
Downstream
Collector
—
toSet()
Stream<Person
>
Classiﬁer
Person→City

Stream<Person>
groupingBy()
bill
jon
amy
London
Athens

Stream<Person>
groupingBy()
bill
jon
amy
London
Athens
bill

Stream<Person>
groupingBy()
bill
jon
amy
London
Athensamy
bill

Stream<Person>
groupingBy()
bill
jon
amy
London
Athens amy
bill

Stream<Person>
groupingBy()
bill
jon
amy
London
Athens amy
jon bill

Stream<Person>
groupingBy()
bill
jon
amy
London
Athens amy
jon
bill

groupingBy()
bill
jon
amy
London
Athens amy
jon
bill

groupingBy()
bill
jon
amy
London
Athens { }amy
{ , }jonbill

mapping(Function mapper,Collector downstream))
Applies a mapping function to each input element before passing it
to the downstream collector.

Set<City> inhabited = people.stream() 
.collect(mapping(Person::getCity,toSet()));
Animation example

Journey’s End, JavaOne, September 2016
LondonStream<Person>
mapping()
bill
jon
amy Athens
Mapper
Person→City
Downstream
Collector
—
toSet()
Stream<City>
Set<City>

mapping()
bill
jon
amy Athens
Set<City>

mapping()
bill
jon
amy Athens
London
Set<City>

mapping()
bill
jon
amy Athens
Athens
London
Set<City>

mapping()
bill
jon
amy Athens
Athens
LondonLondon
Set<City>

London
mapping()
bill
jon
amy Athens
Athens
LondonLondon
Set<City>

London
mapping()
bill
jon
amy
{ ,
}
Athens
Athens
London
Set<City>

Set<City> inhabited = people.stream() 
.collect(mapping(Person::getCity,toSet()));
Map<City,String> namesByCity = people.stream() 
.collect(groupingBy(Person::getCity,
mapping(Person::getName,joining()));
Animation example
Sensible example

Collectors’ Fair, JavaOne, October 2016
groupingBy()
bill
jon
amy Athens
London
Collector<Person,?,String>
Classiﬁer
Person→City
mapping()
Mapper
Person→String
Stream<String>
joining()
Collector<CharSequence,?,String>
Nesting Collectors

Dualling Convenience Reductions
Terminal operation Collectors factory method
count() counting()
max()
min()
maxBy()
minBy()
sum()
average()
summingXxx()
averagingXxx()
summaryStatistics() summarizingXxx()
reduce(accumulator)
reduce(identity, accumulator)
reduce(identity, accumulator, combiner)
reducing(accumulator)
reducing(identity, accumulator)
reducing(identity, accumulator, combiner)

Streams 1I
Demo and labs

What?You Want More??

Lambda/Streams Hands-On Lab

Recommended

Recommended

More Related Content

What's hot

What's hot (17)

Similar to Lambda/Streams Hands-On Lab

Similar to Lambda/Streams Hands-On Lab (20)

More from Maurice Naftalin

More from Maurice Naftalin (9)

Recently uploaded

Recently uploaded (20)

Lambda/Streams Hands-On Lab