Java 8 lambda expressions

Java 8 Lambda Expressions
Logan Chien

2
Agenda
●
Lambda Expression and Closure
●
Stream and Operations
●
Parallelism
●
Functional Interface

4
Background
Before Java 8, there were anonymous classes:
JButton btn = new JButton("Click");
btn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
System.out.println("Button clicked!");
}
});

5
Lambda Expressions
It is cumbersome to write anonymous classes in
many cases. Thus, lambda expressions are
introduced:
JButton btn = new JButton("Click");
btn.addActionListener(
evt -> System.out.println("Button clicked!"));

6
Lambda Syntax
●
No arguments:
●
One argument:
●
Two arguments:
●
With explicit argument types:
●
Multiple statements:
() -> System.out.println("Hello")
s -> System.out.println(s)
(x, y) -> x + y
(Integer x, Integer y) -> x + y
(x, y) -> {
System.out.println(x);
System.out.println(y);
return (x + y);
}

7
Lambda Syntax Sugar 1/2
Method reference
public class HashFunction {
public static int compute1(Object obj) { /*...*/ }
public static int compute2(int a, int b) { /*...*/ }
}
HashFunc::compute1
(x) -> HashFunc::compute1(x)
HashFunc::compute2
(x, y) -> HashFunc::compute2(x, y)
1
2

8
Lambda Syntax Sugar 2/2
Constructor reference
String::new () -> new String()
(x) -> new String(x)
(x, y) -> new String(x, y)
(x, y, z) -> new String(x, y, z)
int[]::new (s) -> new int[s]
1
2

9
Lambda Expression vs. Closure
●
Lambda expression
– A piece of the source code have the semantics like
anonymous classes.
– Evaluated to a closure object in the run-time.
●
Closure
– The run-time object that contains the captured
variables and an associated method.

10
Capture Variable 1/3
●
We can refer to local variables in lambda
expressions.
– The referred local variables should be either final
or effectively final.
●
Evaluation of lambda expression will copy the
referred local variables to closure objects.

11
import java.util.stream.*;
import java.util.function.*;
public class CaptureExample {
public static IntUnaryOperator addBy(int n) {
return (x) -> x + n;
}
public static void main(String[] args) {
IntStream.of(1, 2, 3).map(addBy(1))
.map(addBy(2))
.forEach(System.out::println);
}
}
Capture variable11
2 The lambda expression is evaluated twice. Thus, two
closure objects are returned.

12
import java.util.function.*;
public class NonEffectivelyFinalExample {
public static IntUnaryOperator foo(int a, int n) {
if (a < 0) {
}
n -= a;
}
}
NonEffectivelyFinalExample.java:5: error: local variables referenced from
a lambda expression must be final or effectively final
^
NonEffectivelyFinalExample.java:8: error: local variables referenced from
a lambda expression must be final or effectively final
^
2 errors
Not effectively final

13
Type Inference
What is the type for following lambda
expression?
Ans: It depends on the context. Java compiler
will infer the type automatically.
(x) -> System.out.println(x)
IntConsumer f = (x) -> System.out.println(x);
// (int) -> void
DoubleConsumer g = (x) -> System.out.println(x);
// (double) -> void

16
Big Picture
How to Use Lambdas?
●
Stream – Create a stream from the collections,
arrays, etc.
●
Lazy operations – Operations that will be applied
to stream elements on demand.
●
Eager operations – Operations that will trigger
the evaluations.
– Enumerators, Collectors, etc.

17
Stream
●
Stream is an abstraction of the underlying
data structure.
●
Isolates the data processing and control flow.
●
Abstracts the intermediate data structures.
●
Abstracts the lazy evaluation of operations.

18
How to Create Stream?
●
From programmer-specified elements
●
From arrays
●
From java.util.Collection
●
From java.util.Map
java.util.Stream.of(...)
java.util.Arrays.stream(array)
java.util.Collection.stream()
java.util.Collection.parallelStream()
java.util.Map.entrySet().stream()
java.util.Map.values().stream()

19
Operations
●
Lazy evaluation
– filter
– map
– flatMap
– peek
– ... etc
●
Eager evaluation
– count
– forEach
– toArray
– reduce
– collect
– ... etc
Tips: Check the return type. The lazy operations will return Stream.

21
filter() 1/2
●
filter() takes a predicate function
●
If the predicate function returns false, then
the element will be removed from the
stream.
1 2 3 4 5
1 3 5
Input Stream
Output Stream
…
…
filter(x -> x % 2 != 0)

22
filter() 2/2
public class FilterExample {
Stream.of(1, 2, 3, 4, 5)
.filter(x -> x % 2 != 0)
}
}
1 2 3 4 5
1 3 5
Input Stream
Output Stream
…
…
filter(x -> x % 2 != 0)

23
map() 1/2
●
map() takes an unary function which will
convert one element to another element.
1 3 5Input Stream
Output Stream
…
…S:0 S:1 S:2
map(x -> "S:" + x / 2)

24
public class MapExample {
Stream.of(1, 3, 5)
.map(x -> "S:" + x / 2)
}
}
map() 2/2
1 3 5Input Stream
Output Stream
…
…S:0 S:1 S:2
map(x -> "S:" + x / 2)
Integer
String

25
flatMap() 1/4
●
flatMap() takes an unary function.
●
The unary function will take an element and
return a stream.
●
flatMap() will concatenate these streams.
1 2 3Input Stream
Output Stream
…
…0 0 1 0 1 2
flatMap(x -> IntStream.range(0, x).boxed())

26
flatMap() 2/4
public class FlatMapExample1 {
Stream.of(1, 2, 3)
.flatMap(x -> IntStream.range(0, x).boxed())
}
}
1 2 3Input Stream
Output Stream
…
…0 0 1 0 1 2
flatMap(x -> IntStream.range(0, x).boxed())

27
flatMap() 3/4
A
B
C
a
b bb bbb
c cc
HashMap<String, String[]>
Key Value

28
flatMap() 4/4
import java.util.*;
public class FlatMapExample2 {
HashMap<String, String[]> m =
new HashMap<String, String[]>();
m.put("A", new String[]{"a"});
m.put("B", new String[]{"b", "bb", "bbb"});
m.put("C", new String[]{"c", "cc"});
m.entrySet().stream()
.flatMap(e -> Arrays.stream(e.getValue()))
}
}

29
peek() 1/3
●
peek() is the debug routine.
– e.g. Print the value during the lazy evaluation.
●
It will call the closure method with an element.
– You can print the element.
– You can manipulate the object (but not
recommended.)

30
peek() 2/3
public class PeekExample1 {
Stream.of(1, 2, 3)
.map(x -> x * 2)
.peek(x -> System.out.println("a:" + x))
.map(x -> x + 1)
.peek(x -> System.out.println("b:" + x))
}
};
a:2
b:3
3
a:4
b:5
5
a:6
b:7
7
Output

31
peek() 3/3
class Num {
private int value;
public Num(int i) { value = i; }
public int get() { return value; }
public void set(int i) { value = i; }
};
public class PeekExample2 {
Stream.of(new Num(1), new Num(2), new Num(3))
.peek(x -> x.set(5))
.forEach(x -> System.out.println(x.get()));
}
};
5
5
5
Output

32
Remarks 1/2
●
Lazy operations won't be executed until they
are triggered by an eager operation.
– This example will not print any numbers.
– The lambda expression is evaluated.
– The method in the closure is NOT invoked.
Stream.of(1, 2, 3).filter(x -> {
System.out.println(x);
return true;
});

33
Remarks 2/2
●
It is suggested to use pure functions (i.e. no
side-effects) for these operations.
– It is hard to predict the behavior when we have
both mutability and lazy evaluation.
– Mutable + Lazy Evaluation = Disaster
– Except: For debug purpose only.

35
forEach()
forEach() will iterate through the stream and
invoke the closure method with each element.
Stream.of(1, 2, 3, 4, 5)
.forEach(x -> System.out.println("GOT:" + x));

36
count()
count() counts the number of elements in a
stream.
public class CountExample {
public static boolean isPrime(int i) {
if (i > 2 && i % 2 == 0) return false;
for (int p = 3; p * p <= i; p += 2)
if (i % p == 0) return false;
return true;
}
long num = IntStream.range(2, 100).filter(Count::isPrime).count();
System.out.println("Num primes in [2,100) = " + num);
}
}

37
toArray()
toArray() collects all of the elements from a
stream and put them in a java.lang.Object
array. import java.util.stream.*;
public class ToArrayExample {
Object[] array = Stream.of("apple", "bear", "bat", "cat")
.filter(x -> x.startsWith("b")).toArray();
for (Object s : array) {
System.out.println((String)s);
}
}
}

38
reduce() 1/4
●
There are three overloaded methods
●
Accumulator should be associative.
1
2
3
Optional<T> reduce(BinaryOperator<T> acc)
T reduce(T id, BinaryOperator<T> acc)
<U> U reduce(U id, BiFunction<U, ? super T, U> acc,
BinaryOperator<U> combiner)

39
reduce() 2/4
import java.util.Optional;
public class ReduceExample1 {
public static Optional<Integer> sum(Stream<Integer> s) {
return s.reduce((x, y) -> x + y);
}
System.out.println(sum(Stream.of()));
System.out.println(sum(Stream.of(1)));
System.out.println(sum(Stream.of(1, 2)));
}
}
Output
Optional.empty
Optional[1]
Optional[3]

40
reduce() 3/4
import java.util.Optional;
public class ReduceExample2 {
public static int sum(Stream<Integer> s) {
return s.reduce(0, (x, y) -> x + y);
}
System.out.println(sum(Stream.of()));
System.out.println(sum(Stream.of(1)));
System.out.println(sum(Stream.of(1, 2)));
}
}
Output
0
1
3

41
collect()
●
collect() takes a collector object and send
each element to the collector.
●
It allows the run-time to build the final data
structure gradually.

42
Common Collectors
●
Collectors.toList()
●
Collectors.toSet()
●
Colloctors.groupingBy()
●
Collectors.joining()
●
Find more in java.util.stream.Collectors.

43
collect(toList())
import java.util.List;
public class CollectToListExample {
List<Integer> odds = Stream.of(1, 2, 3, 4, 5)
.filter(x -> x % 2 != 0)
.collect(Collectors.toList());
for (Integer i : odds) {
System.out.println(i);
}
}
}

44
collect(toSet())
import java.util.Set;
public class CollectToSetExample {
Set<Integer> congs = Stream.of(1, 2, 3, 4, 5)
.map(x -> x % 2)
.collect(Collectors.toSet());
for (Integer i : congs) {
System.out.println(i);
}
}
}

45
collect(groupingBy())
import java.util.*;
public class CollectGroupingByExample {
Map<String, List<Integer>> groups =
Stream.of(1, 2, 3, 4, 5)
.collect(Collectors.groupingBy(
x -> x % 2 == 0 ? "even" : "odd"));
for (Map.Entry<String, List<Integer>> e : groups.entrySet()) {
System.out.println(e.getKey() + ":" + e.getValue());
}
}
}

46
collect(joining())
public class CollectJoinExample {
String s = Stream.of(1, 2, 3, 4, 5)
.map(x -> x.toString())
.collect(Collectors.joining(", "));
System.out.println(s);
}
}
Output
1, 2, 3, 4, 5

48
Specialized Types
●
To reduce box/unbox overhead, several
specialized types for int, long, and double are
provided.
– Streams
– Function Interfaces
– Predicate
– Collector

49
Specialized Stream
●
3 specialized (unboxed) streams:
– DoubleStream, IntStream, and LongStream
●
Box streams (convert from TypeStream to Stream<T>)
– Call IntStream.boxed() method.
●
Unbox streams (convert from Stream<T> to IntStream)
– Call Stream<T>.mapToInt() method.

50
Specialized Functions
●
One argument and one return value
– Function<T, R>
– IntFunction<R>
– ToIntFunction<T>
– LongToIntFunction
– UnaryOperator<T>
– IntUnaryOperator
R apply(T t)
R apply(int t)
int applyAsInt(T t)
R apply(R t)
int applyAsInt(int t)
int applyAsInt(long t)

51
Specialized Functions
●
Two arguments and one return value
– BiFunction<T, U, R>
– ToIntBiFunction<T, U>
– BinaryOperator<T>
– IntBinaryOperator
R apply(T t, U u)
int applyAsInt(T t, U u)
R apply(T t, U u)
int applyAsInt(int t, int u)

52
Specialized Predicate
●
Specialized stream requires specialized
predicates.
– allMatch, anyMatch, filter, noneMatch
●
Comparison
– Predicate<T>
– IntPredicate
boolean test(T t)
boolean test(int t)

53
Specialized Collectors Methods
●
Average
●
Summerizing
●
Summing
Collector<T, ?, Double>
averagingInt(ToIntFunction<? super T> mapper)
Collector<T, ?, IntSummaryStatistics>
summerizingInt(ToIntFunction<? super T> mapper)
Collector<T, ?, Integer>
summingInt(ToIntFunction<? super T> mapper)

56
Parallelism
●
If we limit ourselves to this restricted
programming style, then we can (almost) get
parallelism for free.
●
Call parallel() to convert a stream to
parallel stream.

57
Parallelism Example
public class ParallelExample {
public static long sumSeq(long[] array) {
return Arrays.stream(array).sum();
}
public static long sumPar(long[] array) {
return Arrays.stream(array).parallel().sum();
}
int size = 40000000;
long[] array = new long[size];
for (int i = 0; i < size; ++i) array[i] = i;
long startSeq = System.nanoTime();
long resSeq = sumSeq(array);
long durationSeq = System.nanoTime() - startSeq;
long startPar = System.nanoTime();
long resPar = sumPar(array);
long durationPar = System.nanoTime() - startPar;
}
}
Output
resultSeq: 799999980000000
resultPar: 799999980000000
durationSeq: 58598502
durationPar: 21206305

60
How to Receive Lambdas?
●
The closure object is an object that can be passed around.
●
The closure class will implement the specified interface.
●
To run the body of the lambda expression, invoke the
corresponding method.
●
The interface should contain exactly one non-default
abstract method.
– Because we can choose arbitrary method name.

61
Functional Interfaces
●
Interfaces with one non-default method.
●
It is suggested to annotate with:
@FunctionalInterface.
@FunctionalInterface
public interface MouseEventListener {
public void accept(MouseEvent evt);
}
panel.registerListener(
evt -> System.out.println("Processed!"));

62
Functional Interfaces
import java.util.HashSet;
public class Panel {
private HashSet<MouseEventListener> listeners =
new HashSet<MouseEventListener>();
public void registerListener(MouseEventListener cb) {
listeners.add(cb);
}
public void notifyListener(MouseEvent evt) {
listeners.forEach(x -> x.accept(evt));
}
}

63
Default Method
●
Problem: The language designer would like to
add functions to interfaces, but it will break
the existing program.
●
Solution: We can specify the default method in
an interface.
– Default methods should only use other abstract
methods, i.e. no field access is allowed.

64
Default Method
●
Default methods will be inherited (and may be
overrided) when the interface is extended.
●
The closest default method will be chosen.
●
To invoke the super default method, use the
super keyword.
●
It is necessary to override one if there are conflicts.

65
Static Method
●
In Java 8, we can write static methods in
interfaces as well.
●
For example, Stream.of() is a notable static
method in the interface.

Java 8 lambda expressions

More Related Content

What's hot (20)

Similar to Java 8 lambda expressions (20)

Recently uploaded (20)

Java 8 lambda expressions