FUNctional Programming in Java 8

FUNctional Programming
in Java 8
An introduction to functional programming, lambdas, and streams
Richard Walker
September 2016

Outline
 Java is changing
 Paradigm shift
 What is functional programming?
 Anonymous functions (Lambdas)
 Streams
 Filter
 Map
 Reduce
 Examples

Java is evolving and so should we
 “It is not the strongest of the species that survives, nor the most intelligent
that survives. It is the one that is most adaptable to change” – Charles Darwin
 Java 8 allows for cleaner and more concise code
 Takes advantage of multicore architectures without synchronized
Collections.sort(inventory, new Comparator <Apple>() {
public int compare (Apple a1, Apple a2) {
return a1.getWeight().compareTo(a2.getWeight());
}
});
inventory.sort(comparing(Apple::getWeight)); Java 8

We’re still learning how to code
Procedural
Object-
Oriented
Functional
C, Fortran,
Perl
Java, C++,
Python
Lisp, Scala, Clojure,
Java 8*

https://twitter.com/jongold/status/757262853388677120
https://twitter.com/iamdevloper

What is functional programming?
 Declarative Programming Paradigm
 What you want done instead of how it gets done
 Accomplish tasks by composing small functions
 No side effects
 No mutation = easier debugging
 Allows for safe parallelization

Quick Quiz
Imperative Way
int result = 0;
for(int e: numbers) {
if(e % 2 == 0) {
result += e * 2;
}
}
Functional Way I
numbers.stream()
.filter(e -> e % 2 == 0)
.mapToInt(e -> e * 2)
.sum();
Functional Way II
numbers.stream()
.filter(Numbers::evenNumber)
.mapToInt(Numbers::doubleNumber)
.sum();

Lambdas
 Anonymous functions
 like an anonymous inner class
 Functional Interfaces
 An interface with one abstract method (NEW!)*
 1st-class citizens in Java 8
Format:
(parameters) -> (expression)
Examples:
(int a, int b) -> a * b
(a, b) -> a * b

Functional Interfaces in Java
 Oracle provided a bunch of them fresh out of the box!
Predicate<T> : T -> Boolean
Function<T, R> : T -> R
https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

Lambda Example
// Java 7
List<Person> people = loadPeople();
Collections.sort(people, new Comparator<Person>()
{
@Override
public int compare(Person p1, Person p2) {
return p1.name.compareTo(p2.name);
}
});

Lambda Example
// Java 8
Collections.sort(people,
(Person p1, Person p2)
p1.name.compareTo(p2.name);
);

Lambda Example
// Java 8
(Person p1, Person p2) -> p1.name.compareTo(p2.name);
);

Lambda Example
// Java 8
(p1, p2) -> p1.name.compareTo(p2.name);
);

Lambda Example
// Java 8
people.sort((p1, p2) -> p1.name.compareTo(p2.name));
• Less code
• Easier to read
• Less chance for screw ups
We’re using the new sort API added to java.util.List in Java 8 – instead of the old Collections.sort API.

Streams
“The gateway drug of Java 8” - Venkat Subramaniam

What are Streams?
 Allows for Collection manipulation in a
Declarative way
 Functional
 Allows us to abstract away from iteration
 Less boilerplate code
 Allows for composable code
 Greater Flexibility
 Allows for easy (free) parallelization
 Better Performance

Filtering (Extracts)
// Filtering unique elements
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
.filter(i -> i % 2 == 0)
.distinct()
.forEach(System.out::println);

Mapping (Transforms)
// Map
List<String> words = Arrays.asList("Hello", "World");
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(toList());
System.out.println(wordLengths);

Reducing (Folds/Massages)
List<Integer> numbers = Arrays.asList(3,4,5,1,2);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);
System.out.println(sum);
int sum2 = numbers.stream()
.reduce(0, Integer::sum);
System.out.println(sum2);

Filtering (Extracts) faster!
// Filtering unique elements
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.parallelStream()
.filter(i -> i % 2 == 0)
.distinct()
.forEach(System.out::println);

Examples
How can I actually use this at work?

class Person {
Gender gender; String name;
public Gender getGender() { return gender; }
public String getName() { return name; }
}
enum Gender { MALE, FEMALE, OTHER }
List<String> names = new ArrayList<String>();
List<Person> people = …
people.stream()
.filter(p -> p.getGender() == Gender.FEMALE)
.map(Person::getName)
.map(String::toUpperCase)
.forEach(name -> names.add(name));
List of uppercase names of all the “FEMALE” people in
that list

Get the unique surnames in uppercase of the first
15 book authors that are 50 years old or older.
library.stream()
.map(book -> book.getAuthor())
.filter(author -> author.getAge() >= 50)
.map(Author::getSurname)
.map(String::toUpperCase)
.distinct()
.limit(15)
.collect(toList()));

Real-life examples
Reducing QA work one line at a time

QA Implementation Pt.1
public static PartnerInfo[] arrayCopy(final PartnerInfo... info) {
if (info == null) {
return null;
}
final PartnerInfo[] result = new PartnerInfo[info.length];
for (int i = 0; i < info.length; i++) {
result[i] = new PartnerInfo(info[i]);
}
return result;
}
286 chars, 9 lines

QA Implementation Pt.2
public static PartnerInfo[] arrayCopy(final PartnerInfo... info) {
if (info == null) {
return null;
}
// Create a new copy for each PartnerInfo in the list
return Arrays.stream(info)
.map(PartnerInfo::new)
.toArray(PartnerInfo[]::new);
}
194 chars, 7 lines

Differences
Imperative
 9 Lines
 286 Chars
Declarative
 7 Lines
 194 Chars
92 characters less
32.17% decrease!

Conclusion
 Paradigms are changing, and languages are evolving
 Java 8 has a host of new features:
 Lambdas
 Stream API
 Functional Code has the following benefits:
 Flexible
 Less Code*

FUNctional Programming in Java 8

More Related Content

What's hot

Viewers also liked

Similar to FUNctional Programming in Java 8

FUNctional Programming in Java 8

Editor's Notes