Functional Java 8 in everyday life

Functional Java 8
in everyday life
The code is available on:
https://github.com/andreaiacono/Java8

Functional Java8 in everyday life
What's new in Java 8
•Default methods
•Lambda expressions
•Streams
•Optionals
•Date/Time API
Biggest update since Generics in Java 1.5

Background
Anonymous inner classes let define a functional
behaviour, but with a lot of code:
JButton testButton = new JButton("Test Button");
testButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent ae) {
System.out.println("Click!");
}
});
All we need is a way to write only the code
in the method.

Lambda expressions
provide a clear and concise way to represent a ”one abstract method
interface” (a so-called functional interface) using an expression:
JButton testButton = new JButton("Test Button");
testButton.addActionListener(event -> System.out.println("Click!"));
A lambda is composed of three parts:
Argument list Arrow token Body of the method
event → System.out.println("Click!")
It works because the listener has only one abstract method and the
compiler can infer what to do from the interface:
package java.awt.event;
import java.util.EventListener;
public interface ActionListener extends EventListener {
/**
* Invoked when an action occurs.
*/
public void actionPerformed(ActionEvent e);
}

Lambda expressions
Variations in signatures:
Signature Argument
list
Arrow
token Body of the method
void execute() () → System.out.println("foo!")
String getString() () → "foo"
Integer increment(Integer value) (value) → new Integer(value +1)
String concatenate(String a, String b) (a, b) → a.toString() + b.toString()
void process(T t) (t) → {}

Data setup
public class Book {
private List<Author> authors;
private String title;
private int pages;
private Genre genre;
private int year;
private String Isbn;
}
public class Author {
private String name;
private String lastName;
private String country;
}
public enum Genre {
NOVEL, SHORT_NOVEL, NON_FICTION;
}

Lambda sample
We need to find the books with more than 400 pages.
public List getLongBooks(List books) {
List accumulator = new ArrayList<>();
for (Book book : books) {
if (book.getPages() > 400) {
accumulator.add(book);
}
}
return accumulator;
}
Now the requirements has changed and we also need to filter for
genre of the book:
public List getLongNonFictionBooks(List books) {
if (book.getPages() > 400 && Genre.NON_FICTION.equals(book.getGenre())) {
}
}
return accumulator;
}
We need a different method for every filter,
while the only change is the if condition!

Lambda sample
We can use a lambda. First we define a functional interface,
which is an interface with only one abstract method:
@FunctionalInterface
public interface BookFilter {
public boolean test(Book book);
}
Then we can define a generic filter and write as many
implementation we want in just one line:
public static List lambdaFilter(List books, BookFilter bookFilter) {
if (bookFilter.test(book)) {
}
}
return accumulator;
}
// one line filters
List longBooks = lambdaFilter(Setup.books, b -> b.getPages() > 400);
BookFilter nflbFilter = b -> b.getPages() > 400 && Genre.NON_FICTION == b.getGenre();
List longNonFictionBooks = lambdaFilter(Setup.books, nflbFilter);

Functional interfaces
We don't need to write all the functional interfaces because
Java 8 API defines the basic ones in java.util.function package:
Functional interface Descriptor Method name
Predicate<T> T → boolean test()
BiPredicate<T, U> (T, U) → boolean test()
Consumer<T> T → void accept()
BiConsumer<T, U> (T, U) → void accept()
Supplier<T> () → T get()
Function<T, R> T → R apply()
BiFunction<T, U, R> (T, U) → R apply()
UnaryOperator<T> T → T identity()
BinaryOperator<T> (T, T) → T apply()
So we did not need to write the BookFilter interface, because
the Predicate interface has exactly the same descriptor.

Lambda sample
So we can rewrite our code as:
public static List lambdaFilter(List books, Predicate bookFilter) {
}
}
return accumulator;
}
// one line filters
Predicate nflbFilter = b -> b.getPages() > 400 && Genre.NON_FICTION == b.getGenre();

Lambdas and existing interfaces
Since in JDK there are a lot of interfaces with only one
abstract method, we can use lambdas also for them:
// Runnable interface defines void run() method
Runnable r = () -> System.out.println("I'm running!");
r.run();
// Callable defines T call() method
Callable callable = () -> "This is a callable object";
String result = callable.call();
// Comparator defines the int compare(T t1, T t2) method
Comparator bookLengthComparator = (b1, b2) -> b1.getPages() - b2.getPages();
Comparator bookAgeComparator = (b1, b2) -> b1.getYear() - b2.getYear();

Method reference
Sometimes code is more readable if we refer just to the method
name instead of a lambda
Kind of method reference Example
To a static method Integer::parseInt
To an instance method of a class Integer::intValue
To an instance method of an object n::intValue
To a constructor Integer::new
So we can rewrite this lambda
Function<String, Integer> lengthCalculator = (String s) -> s.length();
with a method reference:
Function<String, Integer> lengthCalculator = String::length;

Comparators
In former versions of Java, we had to write an anonymous
inner class to speficy the behaviour of a Comparator:
Collections.sort(users, new Comparator<Author>() {
public int compare(Author a1, Author a2) {
return a1.compareTo(a2.id);
}
});
We can use lambda for making code more readable:
// now sort is a oneliner!
Collections.sort(authors, (Author a1, Author a2) -> a1.compareTo(a2));

Imagine we want to cache
results from DB queries.
This is a first rough version
(too duplicated logic)
class DbCache {
public static enum QueryType {
BOOKS_COUNT, PUBLISHERS_COUNT, COUNTRIES_COUNT;
}
private static Map cache = new HashMap<>();
public static Integer getValue(QueryType queryType) {
Integer count;
switch (queryType) {
case BOOKS_COUNT:
if (cache.containsKey(queryType)) {
return cache.get(queryType);
}
count = countBooks();
cache.put(queryType, count);
return count;
case PUBLISHERS_COUNT:
}
count = countPublishers();
return count;
case COUNTRIES_COUNT:
}
count = countCountries();
return count;
}
}
private static Integer countBooks() {
return 4; // returns a value got from DB query
}
}
// cache call:
Integer booksCount = DbCache.getValue(QueryType.BOOKS_COUNT);

A bit more polished, but still an ”execute around” pattern:
class DbCache {
}
Integer count = cache.get(queryType);
if (count == null) {
switch (queryType) {
case BOOKS_COUNT:
count = countBooks();
break;
case PUBLISHERS_COUNT:
count = countPublishers();
break;
case COUNTRIES_COUNT:
count = countCountries();
break;
}
}
}
return count;
}
// returns a value got from DB query
return 4;
}
}
// cache call:
Integer booksCount = DbCache.getValue(QueryType.BOOKS_COUNT);

Using interfaces the result is better, but still verbose:
class InterfaceCache {
}
public static Integer getValue(QueryType queryType, Counter counter) {
count = counter.count();
}
return count;
}
}
interface Counter {
public Integer count();
}
class BooksCounter implements Counter {
@Override
public Integer count() {
return 4;
}
}
// other Counter implementations
// cache call:
BooksCounter bookCounter = new BooksCounter();
Integer booksCount = getValue(QueryType.BOOKS_COUNT, bookCounter);

We can rewrite the cache with lambdas:
class FunctionalCache {
}
public static Integer getValue(QueryType queryType, Function counter) {
count = counter.apply(queryType);
}
return count;
}
return 4;
}
// other counts from DB..
}
// cache call:
Integer booksCount = FunctionalCache.getValue(QueryType.BOOKS_COUNT, f -> countBooks());

Or we can put the DB queries inside the cache:
class FunctionalMapCache {
private static enum QueryType {
BOOKS_COUNT(() -> countBooks()),
PUBLISHERS_COUNT(() -> countPublishers()),
COUNTRIES_COUNT(() -> countCountries());
private Supplier counter;
QueryType(Supplier counter) {
this.counter = counter;
}
public Supplier getCounter() {
return counter;
}
}
count = queryType.getCounter().get();
}
return count;
}
return 4;
}
// other counts from DB..
}
// cache call:
Integer booksCount = getValue(QueryType.BOOKS_COUNT);

Streams
The Java Collections framework relies on the concept of
external iteration, as in the example below:
for (Book book: books) {
book.setYear = 1900;
}
compared to internal iteration, like the example below:
Books.forEach(b -> book.setYear(1900));
The difference is not only in code readabilty and
maintainability, is also related to performance: the runtime
can optimize the internal iteration for parallelism, lazyness or
reordering the data.

Streams
Let's see again the book filter we wrote with lambdas:
public static List lambdaFilter(List books, Predicate bookFilter) {
}
}
return accumulator;
}
// one line filters
Predicate nflbFilter = b -> b.getPages() > 400 && Genre.NON_FICTION == b.getGenre();
We can rewrite it using streams:
// stream based filters
List longBooks = books.stream().filter(b -> b.getPages() > 400).collect(toList());
List longNonFictionBooks =
books.stream().filter(b -> b.getPages() > 400 && Genre.NON_FICTION == b.getGenre())
.collect(toList());
The code is much cleaner now, because we don't need the
lambdaFilter() method anymore. Let's see how it works.

Streams
List longBooks = books.stream().filter(b -> b.getPages() > 400).collect(toList());
What we've done is:
• calling the stream() method on the collection, for trasforming it
into a stream
• calling the filter() method passing a Predicate, for filtering
the elements of the stream dropping any/some of them
• calling the collect() method with the static import toList()
for collecting the filtered elements and put them into a List
object

Stream operations
Operation Operation type Return type
filter(Predicate<T>) intermediate Stream<T>
map(Function <T, R>) intermediate Stream<R>
flatMap(Function <T, R>) intermediate Stream<R>
distinct() intermediate Stream<T>
sorted(Comparator<T>) intermediate Stream<T>
peek(Consumer<T>) intermediate Stream<T>
limit(int n) intermediate Stream<T>
skip(int n) intermediate Stream<T>
reduce(BinaryOperator<T>) terminal Optional<T>
collect(Collector<T, A, R>) terminal R
forEach(Consumer<T>) terminal void
min(Comparator<T>) terminal Optional<T>
max(Comparator<T>) terminal Optional<T>
count() terminal long
anyMatch(Predicate<T>) terminal boolean
allMatch(Predicate<T>) terminal boolean
noneMatch(Predicate<T>) terminal boolean
findFirst() terminal Optional<T>
findAny() terminal Optional<T>

Streams samples
We need all the books with more than 400 pages.

Streams samples
We need all the books with more than 400 pages. Here's how:
List<Book> longBooks =
books.stream().filter(b -> b.getPages() > 400).collect(toList());

Streams samples
We need the top three longest books.

Streams samples
We need the top three longest books. Here's how:
List<Book> top3LongestBooks =
books.stream().sorted((b1,b2) -> b2.getPages()-b1.getPages()).limit(3).Collect( toList());

Streams samples
We need from the fourth to the last longest books.

Streams samples
We need from the fourth to the last longest books. Here's how:
List<Book> fromFourthLongestBooks =
books.stream().sorted((b1,b2) -> b2.getPages()-b1.getPages()).skip(3).collect(toList());

Streams samples
We need to get all the publishing years.

Streams samples
We need to get all the publishing years. Here's how:
List<Integer> publishingYears =
books.stream().map(b -> b.getYear()).distinct().collect(toList());

Streams samples
We need all the authors.

Streams samples
We need all the authors. Here's how:
Set<Author> authors =
books.stream().flatMap(b -> b.getAuthors().stream()).distinct().collect(toSet());

Streams samples
We need all the origin countries of the authors.

Streams samples
We need all the origin countries of the authors. Here's how:
Set<String> countries =
books.stream().flatMap(b -> b.getAuthors().stream())
.map(author -> author.getCountry()).distinct().collect(toSet());

Optionals
Let's start with an example: ISBN in 2007 has changed from
10 to 13 characters. To check which version of ISBN a book
has we have to write:
boolean isPre2007 = book.getIsbn().length() > 10;
What if a book was published before 1970, when ISBN did not
exist and the property ISBN is null? Without a proper check,
NullPointerException will be thrown at runtime!
Java 8 has introduced the java.util.Optional class. The
code of our Book class can be now written as:
public class Book {
private List<Author> authors;
private String title;
private int pages;
private Optional<String> Isbn;
private Genre genre;
private int year;
}

Optionals
We can set the value with:
book.setIsbn(Optional.of("978000000"));
Or, if the book was published before 1970:
book.setIsbn(Optional.empty());
Or, if we don't know the value in advance:
book.setIsbn(Optional.ofNullable(value));
(in case value is null an empty Optional will be set)
We can now get the value with:
Optional<String> isbn = book.getIsbn();
System.out.println("Isbn: " + isbn.orElse("NOT PRESENT");
If the Optional contains an ISBN it will be returned,
otherwise the string "NOT PRESENT" will be returned.

Other streams samples
We want the most recent published book.

We want the most recent published book. Here's how:
Optional<Book> lastPublishedBook =
books.stream().min(Comparator.comparingInt(Book::getYear));

We want to know if all the books are written by more
than one author.

than one author. Here's how:
boolean onlyShortBooks =
books.stream().allMatch(b -> b.getAuthors().size() > 1);

We want one of the books written by more than one
author.

We want one of the books written by more than one
author. Here's how:
Optional<Book> multiAuthorBook =
books.stream().filter((b -> b.getAuthors().size() > 1)).findAny();

Streams samples
We want the total number of pages published.

Streams samples
We want the total number of pages published. Here's how:
Integer totalPages =
books.stream().map(Book::getPages).reduce(0, (b1, b2) -> b1 + b2);
Optional<Integer> totalPages =
or:
books.stream().map(Book::getPages).reduce(Integer::sum);

Streams samples
or:
We want to know how many pages the longest book has.

Streams samples
or:
We want to know how many pages the longest book has.
Here's how:
Optional<Integer> longestBook =
books.stream().map(Book::getPages).reduce(Integer::max);

The Collector interface
The Collector interface was introduce to give developers a set of
methods for reduction operations.
Method Return type
toList() List<T>
toSet() Set<t>
toCollection() Collection<T>
counting() Long
summingInt() Long
averagingInt() Double
joining() String
maxBy() Optional<T>
minBy() Optional<T>
reducing() ...
groupingBy() Map<K, List<T>>
partioningBy() Map<Boolean, List<T>>

Collector samples
We want the average number of pages of the books.

Collector samples
We want the average number of pages of the books. Here's how:
Double averagePages =
books.stream().collect(averagingInt(Book::getPages));

Collector samples
We want all the titles of the books.

Collector samples
We want all the titles of the books. Here's how:
String allTitles =
books.stream().map(Book::getTitle).collect(joining(", "));

Collector samples
We want all the titles of the books. Here's how:
String allTitles =
books.stream().map(Book::getTitle).collect(joining(", "));
We want the book with the higher number of authors. Here's how:
Optional<Book> higherNumberOfAuthorsBook =
books.stream().collect(maxBy(comparing(b -> b.getAuthors().size())));

Stream grouping
We want a Map of book per year.

Stream grouping
We want a Map of book per year. Here's how:
Map<Integer, List<Book>> booksPerYear =
Setup.books.stream().collect(groupingBy(Book::getYear));

Stream grouping
We want a Map of how many books are published per year per
genre.

Stream grouping
genre. Here's how:
Map<Integer, Map<Genre, List<Book>>> booksPerYearPerGenre =
Setup.books.stream().collect(groupingBy(Book::getYear, groupingBy(Book::getGenre)));

Stream grouping
genre. Here's how:
We want to count how many books are published per year.

Stream grouping
genre. Here's how:
We want to count how many books are published per year.
Here's how:
Map<Integer, Long> bookCountPerYear =
Setup.books.stream().collect(groupingBy(Book::getYear, counting()));

Stream partitioning
We want to classify book by hardcover.

Stream partitioning
We want to classify book by hardcover. Here's how:
Map<Boolean, List<Book>> hardCoverBooks =
books.stream().collect(partitioningBy(Book::hasHardCover));

Stream partitioning
We want to further classify book by genre.

Stream partitioning
We want to further classify book by genre. Here's how:
Map<Boolean, Map<Genre, List<Book>>> hardCoverBooksByGenre =
books.stream().collect(partitioningBy(Book::hasHardCover,groupingBy(Book::getGenre)));

Stream partitioning
We want to count books with/without hardcover.

Stream partitioning
We want to count books with/without hardcover. Here's how:
Map<Boolean, Long> count =
books.stream().collect(partitioningBy(Book::hasHardCover, counting()));

What we did not see:
• Parallel streams
• Streams methods for primitive types

Thanks!
The code is available on:
https://github.com/andreaiacono/Java8

Functional Java 8 in everyday life

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Functional Java 8 in everyday life (20)

More from Andrea Iacono (6)

Recently uploaded (20)

Functional Java 8 in everyday life