Lambda Expressions in Java 8

COP 4331/5339 – OODP/OOSD

Instructor: Dr. Ionut Cardei

Reading material:

Lambda Expressions in Java 8, by Cay Horstmann (Dr.
Dobbs): http://www.drdobbs.com/jvm/lambda-expressions-in-java-8/240166764

Java Tutorial:
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Lambda Quick Start:
http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/Lambda-QuickStart/index.html


Lambda Expressions in Java, by Angelika Langer & Klaus Kreft
http://www.angelikalanger.com/Lambdas/Lambdas.pdf
 Overview

What is a λ-expression ?

Functional Interfaces

Motivation for Lambdas

Lambda Expression for Comparator

Lambda Expression Syntax

Closures and Variable Access

Dealing with Exceptions

Method References

Constructor References

Further Reading
 What is a λ-expression ?

A block of code with parameters, i.e. a function with
no name that can access effectively final variables
from the surrounding scope (lexically scoped)

Captures free variables, instance and class
variables from the enclosing scope

Implemented with a closure.

Lambdas can be stored, referenced by variables
and passed around for execution at a later time
 What is a λ-expression ?

It can be used anywhere where an object
implementing a functional interface is
expected

Other languages supporting lambdas:
 JavaScript, C++, Python, Scala, LISP, Scheme,
Haskell, Matlab, F#, Perl, Lua, PHP, Ruby, TCL
 Introduced by functional languages

Java is very late to this party
 Functional Interfaces

A Java interface with only one abstract (i.e. unimplemented)
method declared in its definition

Optional Java annotation: @FunctionalInterface

Examples:

public interface Comparable<T> { public interface Comparator<T> {

int compareTo(T other); int compare(T p1, T p2);
} }

@FunctionalInterface public interface Runnable

public interface ActionListener {
{ void run();
int actionPerformed(ActionEvent event); }
}
 Motivation for Lambdas

Using named or anonymous classes for instances of
functional interfaces is verbose

The compiler can infer parameter and return types from
actual parameters.
anonymous class

Collections.sort(countries,
new Comparator<Country>() parameter types
{
public int compare(Country country1, Country country2)
{
return country1.getName().compareTo(country2.getName());
}
} );

function definition
useful expression
 Motivation for Lambdas
Sorting with anonymous class object: anonymous class

Collections.sort(countries,
new Comparator<Country>() parameter types
{
public int compare(Country country1, Country country2)
{
return country1.getName().compareTo(country2.getName());
}
});

function definition
useful expression

Same thing, with a lambda expression:

Only the function definition is needed
Collections.sort(countries,
(country1, country2) ->
country1.getName().compareTo(country2.getName());
);
 Motivation for Lambdas

Less typing, more convenient

More readable code

Support for a stream abstraction where objects are processes in a
pipeline mode (and not related to the java.io I/O classes).

Support for lazy evaluation and optimization
– delayed object creation, on demand
– implicit parallelization of code, convenient for programmers,
with parallel streams

Support for Fluent Programming, i.e. chaining an operation that
returns a value followed by an operation that uses that value and
returns a new value, and so on.
Lambda Expression for Comparator

Same example, now with a lambda-expression (in blue color):

Collections.sort(countries,
(Country country1, Country country2) ->
country1.getName().compareTo(country2.getName());
);


If the compiler can infer parameter types, we can omit
them:
Collections.sort(countries,
(country1, country2) ->
country1.getName().compareTo(country2.getName());
);
 Lambda Expression Syntax

For a code block of one statement:
(paramlist) -> expression

For a code block of multiple statements:
(paramlist) -> {
statement1; …....
statementn;
}
 If the lambda returns a statement: use return expr;

 (paramlist) is (Type1 p1, … , Typen pn)


If the parameter list has just one parameter with inferred type,
you can omit the parentheses

No need to specify return type
 Lambda Expression with Multiple
Statements

A Comparator<String> comparing string lengths
Collections.sort(stringlist,
(String s1, String s2) -> {
if (s1.length() < s2.length()) return -1;
if (s1.length() > s2.length()) return +1;
return 0;
} );

An ActionListener (from Chapter 4):
helloButton.addListener(
event -> { // or (event) or (ActionEvent event)
String s = jText1.getText();
System.out.println(“the text was “ + s);
jText1.setText(“Hello World”);
} );
 Parameterless Lambdas

Simply write () as the parameter list:

Example that creates a new thread from a
Runnable object and starts the thread:
new Thread(
( ) -> { // Runnable has method void run()
System.out.println(“runs in another thread”);
}
).start();

(in this one line function example the { and } are optional.
I wrote them because of the comment.)
 Closures and Variable Access

A closure is a function together with its environment:
– actual parameters, instance and class variables from
the enclosing class
– ... plus local variables that are effectively final (called
free variables)

for (int i=0; i<n; i++) {

final int index = i; // a final variable
Date now = new Date(); // an effectively final variable

new Thread(
( ) -> {
System.out.println(“thread started, index “ + index + “ at
time “ + now);
}
);
} // for i=...
 Closures and Variable Access

Lexical scope: the lambda expression is not a scope
of it own, but it is part of the enclosing scope

“this” and “super” refer to the enclosing class

for (int i=0; i<n; i++) {

final int index = i; // final, a “free variable”

new Thread(
( ) -> {
System.out.println(“thread started by “ + this.toString()
+ “ object, with loop index “ + index);
}
);
} // for i=...
 What are Lambdas, Actually ??

A lambda is represented in the JVM by an instance of an
anonymous and hidden class generated by the compiler, that
implements the target functional interface.

Lazy instantiation: object is not created unless used at runtime.


Example:
Comparator <String> comp = (s1, s2) -> {
if (s1.length() < s2.length()) return -1;
if (s1.length() > s2.length()) return +1;
return 0;
};
 Class Object's Methods

Methods (toString, hashCode, equals, clone...)
are inherited by all classes → they are NOT
abstract.

A functional interface may include them:
@FunctionalInterface
interface Function1 <R,T> {
String toString(); // inherited from Object

boolean equals(Object ob); // inherited from Object

R apply(T t); // function with one param

};
 Dealing with Exceptions

The lambda expression (code block) must
comply with the function signature in its
interface definition.

If a function does not throw checked exception,
than we must use try-catch:
new Thread(
( ) -> { // Runnable's method void run()
System.out.println(“runs in another thread”);
Thread.sleep(1000);
}
).start();
Trouble ! sleep() is declared
to throw checked InterruptedException
 Dealing with Exceptions

The lambda expression (code block) must
comply with the function signature in its
interface definition.

If a function does not throw checked exception,
than we must use try-catch:
new Thread(
( ) -> { // Runnable's method void run()
System.out.println(“runs in another thread”);
try { Thread.sleep(1000);
} catch (InterruptedException ex) { }
}
).start(); Solution: try – catch block
 Method References

If a proper method already exists, we can use it

Example:
 When mouse click on JButton, display the event.
With a lambda expression:
jButton.addActionListener(
event -> System.out.println(event)
);
 With a method reference:
jButton.addActionListener(
System.out::println
);
 Method References

Method reference wrapped in compatible
lambda expression

Three cases:
 object::instanceMethod e.g. System.out::println
 Class::staticMethod e.g. Math::sqrt
 Class::instanceMethod e.g. Double::compareTo
 Method References

object::instanceMethod

jButton.addActionListener(
event -> System.out.println(event)
);

same as:

jButton.addActionListener(
System.out::println
);
Instance method
object reference from class PrintStream
 Method References

Class::staticMethod

Suppose we want to create a stream of Doubles, compute square
roots for them, then display them to System.out:

List<Double> dl = Arrays.asList(0.5, 1.0, 3.0, -2.0);


With lambda expression :

dl.stream().map( x -> Math.sqrt(x) )

.forEach( y -> System.out.println(y) );

Same with Class::staticMethod reference (Math::sqrt) :

dl.stream().map( Math::sqrt )
.forEach( y -> System.out.println(y) );
 Method References

Class::instanceMethod
 Suppose the functional interface abstract function is defined
as:
Type1 instanceMethod(Type2 y, Type3 z);
 The first parameter in the lambda call becomes the target of
the method (the implicit parameter), the second becomes y,
the third becomes z, etc.

E.g. instance method compareTo() from class Double is defined
as:
int compareTo(Double other)
 Method References

Class::instanceMethod (continued)

Sorting List <Double>:

List<Double> dl = Arrays.asList(3.0, 4.0, 2.0, 1.0);


Sorting with a lambda matching a Comparator<Double>:

Collections.sort(dl, (x,y) -> x.compareTo(y) );


Equivalent, with a method reference, Double::compareTo

Collections.sort(dl, Double::compareTo );
 Constructor Reference

Similar to method references where the method name
is “new”.

Example: create array of JButtons from a list of labels
 Function stream() creates a stream of objects
 function map() calls the passed lambda on each stream
element and returns the new stream)
List<String> labels = new ArrayList<String>();

labels.add(“Hello”); labels.add(“Goodbye”);

Stream<JButton> stream = labels.stream().map( JButton::new);

List<Button> buttons = stream.collect(Collectors.toList());
same as
Stream<JButton> stream =labels.stream().map( (String s) -> new
JButton(s));
 Further Reading

The java.util.function package

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html


The Java Stream API
 https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

 Tutorials:
http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html

 http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/