Do you want to learn functional programming in Java using lambda expressions introduced in Java 8? Do you want to explore the foundational concepts to explore powerful stream API? This presentation provides an overview of lambda functions introduced in Java 8 through examples. Topics covered: What is functional programming, creating lambda expressions, functional interfaces, built-in functional interfaces, and method references. Make sure you have JDK 8 installed for trying out the programs as you go through the self-contained programming examples.

1. Lambda Functions in Java 8
Ganesh Samarthyam
ganesh.samarthyam@gmail.com
www.designsmells.com
@GSamarthyam

2. Java is evolving…

3. Lambdas added in Java 8

4. Java 8 streams (and parallel streams):
Excellent example of applying functional
programming in practice

5. One-liner #1
Files.lines(Paths.get("FileRead.java")).forEach(System.out::println);
This code prints the contents of
the file “FileRead.java” in the
current directory

6. One-liner #2
Pattern.compile(" ").splitAsStream("java 8 streams").forEach(System.out::println);
This code splits the input string “java 8
streams” based on whitespace and hence
prints the strings “java”, “8”, and
“streams” on the console

7. One-liner #3
new Random().ints().limit(5).forEach(System.out::println);
Generates 5 random integers and prints
them on the console

8. One-liner #4
"hello".chars().sorted().forEach(ch -> System.out.printf("%c ", ch));
Extracts characters in the string “hello”,
sorts the chars and prints the chars

9. Productive programming with lambdas

10. Productive programming with lambdas
public static void main(String []file) throws Exception {
// process each file passed as argument
// try opening the file with FileReader
try (FileReader inputFile = new FileReader(file[0])) {
int ch = 0;
while( (ch = inputFile.read()) != -1) {
// ch is of type int - convert it back to char
System.out.print( (char)ch );
}
}
// try-with-resources will automatically release FileReader object
}
public static void main(String []file) throws Exception {
// read the file line-by-line and print it on the console
Files.lines(Paths.get(file[0])).forEach(System.out::println);
}

11. Functional programming in Java 8

12. What is different with functional programming?
if
while
for
switch

13. Perspective - for loops!
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
for(String string : strings) {
System.out.println(string);
}
External Iteration

14. Perspective - for loops!
Arrays.asList("eeny", "meeny", "miny", “mo”)
.forEach(string -> System.out.println(string));
Internal Iteration

15. Perspective - for loops!
Arrays.asList("eeny", "meeny", "miny", “mo”)
.forEach(string -> System.out.println(string));
Internal Iteration
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
for(String string : strings) {
System.out.println(string);
}
External Iteration
Lambda
expression

16. Perspective - for loops!
Arrays.asList("eeny", "meeny", "miny", “mo”)
.forEach(string -> System.out.println(string));
Internal Iteration
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
for(String string : strings) {
System.out.println(string);
}
External Iteration
Procedural
approach
Functional
approach

17. Let’s get started!

18. Introducing lambdas

19. Lambdas
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = string -> System.out.println(string);
strings.forEach(printString);
Lambda
functions!

20. Lambdas
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = string -> System.out.println(string);
strings.forEach(printString);
Capture in a
variable
Execute later

21. What are lambda functions?
❖ (Java 8) One way to think about lambdas is
“anonymous function” or “unnamed function” - they
are functions without a name and are not associated
with any class
❖ Functions don’t change external state

22. What is functional programming?
❖ Functions are entities that accepts input(s) and produces
an output
Underlying approach:
“Evaluate an expression.
Then use the results for
something else.”

23. Composing functions
❖ Functions are connected together by their outputs to
other functions’ inputs
sediment
pre-
carbon
ultra-filter
post-
carbon
Filtered
water

24. Let’s get our hands dirty!
❖ Make sure you have JDK 8
installed
❖ Try out the programs in your
machine (using IDE of your
choice)

25. Java 8 lambdas - “Hello world!”
interface LambdaFunction {
void call();
}
class FirstLambda {
public static void main(String []args) {
LambdaFunction lambdaFunction = () -> System.out.println("Hello world");
lambdaFunction.call();
}
}

26. Java 8 lambdas - “Hello world!”
interface LambdaFunction {
void call();
}
class FirstLambda {
public static void main(String []args) {
LambdaFunction lambdaFunction = () -> System.out.println("Hello world");
lambdaFunction.call();
}
}
Functional interface - provides
signature for lambda functions
Lambda function/expression
Call to the lambda
Prints “Hello world” on the console when executed

27. Parts of a lambda expression
() -> System.out.println("Hello world");
No parameters, i.e., ()
Arrow operator that separates
parameters and the body
The lambda body
Return type “void” inferred from the body

28. Functional interfaces
@FunctionalInterface
interface LambdaFunction {
void call();
}
Functional interface
Abstract method providing the signature of the
lambda function
Annotation to explicitly state that it is a functional
interface

29. Older Single Abstract Methods (SAMs)
// in java.lang package
interface Runnable { void run(); }
// in java.util package
interface Comparator<T> { boolean compare(T x, T y); }
// java.awt.event package:
interface ActionListener { void actionPerformed(ActionEvent e) }
// java.io package
interface FileFilter { boolean accept(File pathName); }

30. Default methods in interfaces
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}

31. “Diamond” inheritance problem?

32. “Diamond” inheritance problem?
interface Interface1 {
default public void foo() { System.out.println("Interface1’s foo"); }
}
interface Interface2 {
default public void foo() { System.out.println("Interface2’s foo"); }
}
public class Diamond implements Interface1, Interface2 {
public static void main(String []args) {
new Diamond().foo();
}
}
Error:(9, 8) java: class Diamond inherits unrelated defaults for foo()
from types Interface1 and Interface2

33. “Diamond” inheritance problem?
interface Interface1 {
default public void foo() { System.out.println("Interface1’s foo"); }
}
interface Interface2 {
default public void foo() { System.out.println("Interface2’s foo"); }
}
public class Diamond implements Interface1, Interface2 {
public void foo() { Interface1.super.foo(); }
public static void main(String []args) {
new Diamond().foo();
}
}
Add this definition
to resolve the
ambiguity

34. “Diamond” inheritance problem?
class BaseClass {
public void foo() { System.out.println("BaseClass’s foo"); }
}
interface BaseInterface {
default public void foo() { System.out.println("BaseInterface’s foo”); }
}
public class Diamond extends BaseClass implements BaseInterface {
public static void main(String []args) {
new Diamond().foo();
}
}
Compiles cleanly; Java 8
rules help deal with the
diamond problem

35. Using built-in functional interfaces
// within Iterable interface
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
// in java.util.function package
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
// the default andThen method elided
}

36. Using built-in functional interfaces
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = string -> System.out.println(string);
strings.forEach(printString);
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
strings.forEach(string -> System.out.println(string));

37. Built-in interfaces
Predicate<T> Checks a condition and returns a
boolean value as result
In filter() method in
java.util.stream.Stream
which is used to remove elements
in the stream that don’t match the
given condition (i.e., predicate) asConsumer<T> Operation that takes an argument but
returns nothing
In forEach() method in
collections and in
java.util.stream.Stream; this
method is used for traversing all
the elements in the collection orFunction<T,
R>
Functions that take an argument and
return a result
In map() method in
java.util.stream.Stream to
transform or operate on the passed
value and return a result.
Supplier<T> Operation that returns a value to the
caller (the returned value could be
same or different values)
In generate() method in
java.util.stream.Stream to
create a infinite stream of
elements.

38. Built-in interfaces

39. Method references
Method references - “syntactic sugar” for lambda
functions
They “route” function parameters
arg -> System.out.println(arg)
System.out::println

40. Method references
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = System.out::println;
strings.forEach(printString);
Method
reference
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = string -> System.out.println(string);
strings.forEach(printString);

41. Method references
Cannot use method references when lambda functions do
more than“routing” function parameters
strings.forEach(string -> System.out.println(string.toUpperCase()));
More processing here than just
“routing” parameters

42. Method references
List<String> strings = Arrays.asList("eeny", "meeny", "miny", "mo");
Consumer<String> printString = System.out::println;
strings.forEach(printString);
public static void printUpperCaseString(String string) {
System.out.println(string.toUpperCase());
}
strings.forEach(MethodReference::printUpperCaseString);

43. “Effectively final” variables
import java.util.Arrays;
import java.util.List;
class PigLatin {
public static void main(String []args) {
String suffix = "ay";
List<String> strings = Arrays.asList("one", "two", "three", "four");
strings.forEach(string -> System.out.println(string + suffix));
}
} Accessing “local variable” suffix
here; hence it is considered
“effectively final”

44. “Effectively final” variables
import java.util.Arrays;
import java.util.List;
class PigLatin {
public static void main(String []args) {
String suffix = "ay";
List<String> strings = Arrays.asList("one", "two", "three", “four");
suffix = "e"; // assign to suffix variable
strings.forEach(string -> System.out.println(string + suffix));
}
}
PigLatinAssign.java:9: error: local variables referenced from a
lambda expression must be final or effectively final
strings.forEach(string -> System.out.println(string + suffix));
^
1 error

45. Wrap-up: example using streams
import java.util.stream.*;
import java.nio.file.*;
import java.util.*;
import java.nio.charset.Charset;
import java.io.IOException;
class ReadFile {
public static void main(String []args) throws IOException {
List<String> lines = Files.readAllLines(Paths.get("./Ulysses.txt"),
Charset.defaultCharset());
Map<Integer, List<String>> wordGroups
= lines.parallelStream()
.map(line -> line.replaceAll("W", " ").split(" "))
.flatMap(Arrays::stream)
.filter(str -> str.length() > 7)
.distinct()
.sorted()
.collect(Collectors.groupingBy(String::length));
wordGroups.forEach( (count, words) -> {
System.out.printf("word(s) of length %d %n", count);
words.forEach(System.out::println); });
}
}
Lists words organised by
their length in the novel
“Ulysses.txt”

47. Adapt: Learn functional
programming

48. Check out our book!
❖ Programming examples are
from our book:
❖ Oracle Certified Professional
Java SE 8 Programmer Exam
1Z0-809: A Comprehensive
OCPJP 8 Certification Guide,
S.G. Ganesh, Hari Kiran
Kumar, Tushar Sharma, Apress,
2016.
❖ Website: ocpjava.wordpress.com

49. www.designsmells.com bit.ly/sgganesh @GSamarthyam