Xlab #1: Advantages of functional programming in Java 8

www.xsolve.plAgile Software House
Advantages of functional
programming in Java 8

● 10:00 - 10:25 Welcome!
● 10:30 - 10:40 Functional Programming
● 10:40 - 11:55 Lambdas
● 12:10 - 13:25 Streams
● 13:55 - 15:00 File IO
Agenda

Functional Programming
● Concise
● Little “Boilerplate”

Functional Programming in JVM
● Groovy: Closures
● Java 6:
● Java8 - Lambdas!

Lambdas

// Java 7
button.addActionListener( new ActionListener () {
@Override
public void actionPerformed(ActionEvent e){
doSomethingWith(e) ;
}
});
Motivation
// Java 8
button.addActionListener(
e -> doSomethingWith(e)) ;
vs

// Java 7
Collections. sort(list, new Comparator<Integer>() {
@Overide
public int compare(final Integer o1,
final Integer o2) {
return o2.compareTo(o1) ;
}
});
Motivation
// Java 8
Collections. sort(
list, (o1, o2) -> o2.compareTo(o1)) ;
vs

Lambda syntax
new Comparator<String>() {
@Override
public int compare(final String s1, final String s2) {
return s1.length() - s2.length();
}
}
(s1, s2) -> {
}
(s1, s2) -> s1.length() - s2.length()
(final String s1, final String s2) -> {
}
}
}
@Override
}
}
(s1, s2) -> {
}

Sorting Strings by Length
// Java 7 example
Collections .sort(list,
@Override
return s1.length() - s2.length() ;
}
}
);
// Java 8 alternative
Collections .sort(list, (s1, s2) -> s1.length() - s2.length()) ;

Lambda syntax (one argument)
(s) -> s.toUpperCase()
() -> doSomething()
s -> s.toUpperCase()

Method references
(args) -> ClassName.staticMethodName( args)
ClassName::staticMethodName
// Examples
Math::cos
Arrays::sort
String::valueOf
String::length
Integer::compareTo

Method references
Method Ref Type Example Equivalent Lambda
SomeClass::staticMethod Math::cos x -> Math.cos(x)
someObject::instanceMethod someString::toUpperCase () -> someString.toUpperCase()
SomeClass::instanceMethod String::toUpperCase s -> s.toUpperCase()
SomeClass::new Employee::new () -> new Employee()

Lambdas with big body
addActionListener(e -> {
prepareFuel();
/*
…
*/
launch(e);
});
addActionListener(this::fireNuclearRocket);
void fireNuclearRocket(ActionEvent e) {
prepareFuel();
/*
…
*/
launch(e);
}

Functional interface
@FunctionalInterface
interface MyOperation {
String apply(String s);
}
String transform(String s, MyOperation mo) {
String result = mo.apply(s) ;
log(s + " : " + result);
return result;
} // Java 7
transform("Java8", new MyOperation() {
@Override
public String apply(String s) {
return s.toUpperCase() ;
}
});
// Java 8
transform("Java8", s -> s.toUpperCase()) ;

Simplification 1
transform("Java8", s -> s.toUpperCase()) ; transform("Java8", String::toLowerCase );
transform("Java8", String::toUpperCase) ;
transform("Java8", String::trim);

Simplification 2 (java.util.function)
// before
@FunctionalInterface
interface MyOperation {
String apply(String s);
}
String transform(String s, MyOperation mo) {
String result = mo.apply(s) ;
log(s + " : " + result);
return result;
}
// after
String transform(String s, UnaryOperator <String> uo) {
String result = uo.apply(s) ;
log(s + "<->" + result);
return result;
}

java.util.function
INTERFACE METHOD
Consumer<T> void accept(T t)
Supplier<T> T get()
Function<T, R> R apply(T t)
UnaryOperator<T> T apply(T t)
Predicate<T> boolean test(T t)

Lambdas summary
● Lambda syntax: (arg1, arg2) -> arg2.compareTo(arg1)
● Method references: String::length
● @FunctionalInterface
● java.util.function

Streams - motivation
● C / C++ - arrays…
● Java / C# - Collections (List, Set…)
● Java 8 - Streams - Collections taken to another level!

Streams - example
protected List<Book> books = new ArrayList<>();
public void init(){
String tolkien = "J.R.R. Tolkien";
String rowling = "J.K. Rowling";
String norris = "David Norris";
String theGod = "God Almighty";
books.addAll(Arrays.asList(
new Book("The Lord of the Rings", tolkien, 1216),
new Book("Silmarillion", tolkien, 365),
new Book("Harry Potter and the Philosopher's Stone", rowling, 223),
new Book("Harry Potter and the Half-Blood Prince", rowling, 554),
new Book("Harry Potter and the Deathly Hallows", rowling, 607),
new Book("Teach yourself Croatian", norris, 352),
new Book("The Bible", theGod, 1200),
new Book("The Hobbit", tolkien, 320)
));
TODO: find out● the authors● of the top-3● thickest books● other than the Bible

Streams - example
// 1. filter out the Bible
List<Book> booksFiltered = new ArrayList<>();
for (Book book : books){
if (! "The Bible".equals(book.getTitle())) {
booksFiltered.add(book);
}
}
Java7 approach

Streams - example
// 2. sort by number of pages, descending
booksFiltered.sort(new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o2.getPages().compareTo(o1.getPages());
}
});
Java7 approach

Streams - example
// 3. list the authors
for (int i=0; i<3; i++) {
System.out.println(booksFiltered.get(i).getAuthor());
}
Java7 approach

Streams - example
books.stream()
.filter(b -> ! "The Bible".equals(b.getTitle()))
.sorted((b1, b2) -> b2.getPages().compareTo(b1.getPages()))
.limit(3)
.map(Book::getAuthor)
.distinct()
.forEach(System.out::println);
Streams to the rescue!
TODO: find out● the authors● of the top-3● thickest books● other than the Bible

Streams - what are they?
● Interface: Stream<String>, Stream<Book>...
● NOT data structures
● Just wrappers around existing data sources (Collections, Files…)
● Do NOT modify the contents of the underlying data sources
● InputStream, ObjectInputStream, FileInputStream

Streams - characteristics
● Easily obtained from arrays or Collections
List aList = new ArrayList();
aList.stream();
Collection aCollection = new LinkedHashSet<>();
aCollection.stream();
Integer[] anArray = {1, 2, 3, 4, 5};
Stream.of(anArray); // Stream<Integer>
Stream.of("Hickory", "Dickory", "Dock");
// Stream<String>
aList.stream().filter(o -> o != null);
// Stream from another stream!
Chaining!

● ...and transformed into arrays or Collections
List aList =
aStream.collect(Collectors.toList());
Object[] anArray = aStream.toArray();

● Designed for Lambdas
aStream
.filter(b -> ! "Moby Dick".equals(b.getTitle()))
.sorted((b1, b2) ->
b2.getPages().compareTo(b1.getPages()))
.map(Book::getAuthor)

● Lazy (!)

● Lazy (!)
● Parallelizable (!!!)
bookCollection.parallelStream().forEach(book -> {
// do some badass long operation on the book
}
);
bookStream.parallel().forEach(book -> {
// do some badass long operation on the book
}
);

Streams - core methods (1/3)
● forEach
void forEach(Consumer)
void forEachOrdered(Consumer)
Stream.of("Facebook", "Google", "xSolve")
output?
List<String> list =
Arrays.asList("Facebook",
"Google", "xSolve");
list.stream().forEach(String::toUpperCase);
System.out.println(list);
output?
.forEach(System.out::println).forEach
output:
Facebook
Google
xSolve
List<String> list =
Arrays.asList("Facebook",
"Google", "xSolve");
list.stream().forEach(String::toUpperCase);
System.out.println(list);
output: [Facebook, Google, xSolve]

● forEach
● map
(mapToDouble, mapToInt, mapToLong)
Stream map(Function mapper)
.map(str -> str.startsWith("x"))
output?
int sum = Stream.of("1", "2", "3")
.mapToInt(Integer::parseInt)
.sum();
System.out.println(sum);
output?
.map(str -> str.startsWith("x"))
output:
false
false
true
int sum = Stream.of("1", "2", "3")
.mapToInt(Integer::parseInt)
.sum();
System.out.println(sum);
output:
6

● forEach
● map
(mapToDouble, mapToInt, mapToLong)
Stream map(Function)
● filter
Stream filter(Predicate)
.filter(str ->
Character.isLowerCase(str.charAt(0)))
output?
.filter(str ->
Character.isLowerCase(str.charAt(0)))
output: xSolve

● findFirst
Optional findFirst()
String firstFound = Stream.of("Facebook",
"Google", "xSolve")
.filter(str -> str.contains("oo"))
.findFirst()
.get();
output?
String notFound = Stream.of("Facebook",
"Google", "xSolve")
.filter(str -> str.contains("yay!"))
.findFirst()
.orElse("404 not found :(");
System.out.println(notFound);
output?
String firstFound = Stream.of("Facebook",
"Google", "xSolve")
.filter(str -> str.contains("oo"))
.findFirst()
.get();
output: Facebook
String notFound = Stream.of("Facebook",
"Google", "xSolve")
.filter(str -> str.contains("yay!"))
.findFirst()
.orElse("404 not found :(");
System.out.println(notFound);
output:
404 not found :(

● findFirst
● findAny
Optional findAny()
String anyFound = Stream.of("Facebook",
"Google", "xSolve")
.parallel()
.findAny()
.get();
System.out.println(anyFound);
output?
String anyFound = Stream.of("Facebook",
"Google", "xSolve")
.parallel()
.findAny()
.get();
System.out.println(anyFound);
output: Facebook
or: Google
or: xSolve

● findFirst
● findAny
Optional findAny()
● collect
collect(Collector collector)
List<String> uppers = Stream.of("cyan",
"magenta", "yellow", "black")
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(uppers);
output?
List<String> uppers = Stream.of("cyan",
System.out.println(uppers);
output: [CYAN, MAGENTA, YELLOW, BLACK]

● findFirst
● findAny
Optional findAny()
● collect
collect(Collector collector)
● toArray
Object[] toArray()
Object[] objArray = Stream.of("cyan",
.toArray();
String[] strArray = Stream.of("cyan",
.toArray(String[]::new);

● Reduce
T reduce(T starter, BinaryOperator)
Optional reduce(BinaryOperator)
String concatStarter =
Stream.of("A", "n", "n", "a")
.reduce("Lady ", String::concat);
System.out.println(concatStarter);
output?
String concat =
.reduce(String::concat)
.get();
System.out.println(concat);
output?
❏ Stream → single value
❏ IntStream – min(), max(),
sum(), average()
String concatStarter =
.reduce("Lady ", String::concat);
System.out.println(concatStarter);
output: Lady Anna
String concat =
.reduce(String::concat)
.get();
System.out.println(concat);
output: Anna

● Reduce
T reduce(T starter, BinaryOperator)
Optional reduce(BinaryOperator)
● boolean allMatch(Predicate)
boolean noneMatch(Predicate)
boolean anyMatch(Predicate)
boolean allMatch = Stream.of("Veronica",
"Anna", "Patricia", "Alan", "Thomas")
.allMatch(str -> str.endsWith("a"));
System.out.println(allMatch);
output?
boolean noneMatch = Stream.of("Veronica",
.noneMatch(str -> str.endsWith("a"));
System.out.println(noneMatch);
output?
boolean anyMatch = Stream.of("Veronica",
.anyMatch(str -> str.endsWith("a"));
System.out.println(anyMatch);
output?
boolean allMatch = Stream.of("Veronica",
.allMatch(str -> str.endsWith("a"));
System.out.println(allMatch);
output: false
boolean noneMatch = Stream.of("Veronica",
.noneMatch(str -> str.endsWith("a"));
System.out.println(noneMatch);
output: false
boolean anyMatch = Stream.of("Veronica",
.anyMatch(str -> str.endsWith("a"));
System.out.println(anyMatch);
output: true

Streams - core methods (3.5/3)
● long count()
● Stream sorted()
● Stream distinct()
● Stream limit(long maxSize)
● Stream skip(long n)

Streams - Terminal vs Non Terminal operations
Terminal
(consume a Stream)
● forEach, forEachOrdered
● toArray, reduce, collect
● min, max, count
● anyMatch, allMatch,
noneMatch
● findFirst, findAny
Non-terminal
(return another Stream)
● map
● filter
● distinct, sorted
● peek
● limit, skip
● parallel, sequential,
unordered
Terminal
(consume a Stream)
● forEach, forEachOrdered
● toArray, reduce, collect
● min, max, count
● anyMatch, allMatch,
noneMatch
● findFirst, findAny
Non-terminal
(return another Stream)
● map
● filter
● distinct, sorted
● peek
● limit, skip
● parallel, sequential,
unordered
Short-circuit
operations

Streams - lazy evaluation
books.addAll(Arrays. asList(
new Book("The Lord of the Rings" , tolkien, 1216),
new Book("Silmarillion" , tolkien, 365),
new Book("Harry Potter and something" , rowling, 223),
new Book("Harry Potter and blahblah" , rowling, 554)
// + 500k entries
));
books.stream()
.filter(it -> {
System. out.println("name: " + nameFilterCounter ++);
return "J.K. Rowling" .equals(it.getAuthor()) ;
})
.filter(it -> {
System. out.println("tpages: " +
pageFilterCounter ++);
return it.getPages() > 500;
})
.findFirst() ;
name: 0
name: 1
name: 2
pages: 0
name: 3
pages: 1
books.addAll(Arrays. asList(
new Book("The Lord of the Rings" , tolkien, 1216),
new Book("Silmarillion" , tolkien, 365),
new Book("Harry Potter and something" , rowling, 223),
new Book("Harry Potter and blahblah" , rowling, 554)
// + 500k entries
));
books.stream()
.filter(it -> {
System. out.println("name: " + nameFilterCounter ++);
return "J.K. Rowling" .equals(it.getAuthor()) ;
})
.filter(it -> {
System. out.println("tpages: " +
pageFilterCounter ++);
return it.getPages() > 500;
})
.findFirst(); ← short-circuit operation!

Streams - what you can’t do
● Reuse Stream stream = Stream.of("J", "a", "v", "a");
stream.filter(...).map(...)
stream.map(...).forEach(...)

Streams - what you can’t do
● Reuse
● Change surrounding local variables
int total = 0;
Stream.of("Mercury", "Venus", "Mars")
.forEach(str -> {
total += str.length();
});
int[] total = {0};
Stream.of("Mercury", "Venus", "Mars")
.forEach(str -> {
total[0] += str.length();
});
...but:

File IO

File IO
Java6 approach
public void readFile() {
File file =
new File("/home/grzegorz/file.txt");
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
int content;
while ((content = fis.read()) != -1) {
System.out.print((char) content);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != fis) {
try {
fis.close();
}
}
}
}

File IO
Java6 approach
Java7 approach
- java.lang.AutoCloseable
- java.io.Closeable
File file =
try (FileInputStream fis =
new FileInputStream(file)) {
int content;
}
}
}
File file =
try {
int content;
}
} finally {
if (null != fis) {
try {
fis.close();
}
}
}
}

File IO
Path filePath =
Paths.get("/home/grzegorz/file.txt");
try (Stream<String> stream =
Files.lines(filePath)) {
stream.forEach(System.out::print);
}
}
Java8 approach
File file =
try (FileInputStream fis =
new FileInputStream(file)) {
int content;
}
}
}
Java7 approach

File IO
File file =
try {
int content;
}
} finally {
if (null != fis) {
try {
fis.close();
}
}
}
}
Java6 approach
Path filePath =
Paths.get("/home/grzegorz/file.txt");
try (Stream<String> stream =
Files.lines(filePath)) {
stream.forEach(System.out::print);
}
}
Java8 approach
vs.

File IO - Path vs. File
“There is no one-to-one correspondence between the two APIs …”
http://docs.oracle.com/javase/tutorial/essential/io/legacy.html

File IO - How to get Path?
Path p1 = Paths.get("some-file.txt");
Path p2 = Paths.get("C:MyFolderanother-file.txt");

File IO - Methods of Path class
Methods:
toAbsolutePath, startsWith, endsWith, getFileName, getName,
getNameCount, subpath, getParent, getRoot, normalize, relativize
Sample Method Result
toAbsolutePath C:eclipse-workspacejavafile-ioinput-file.txt
getFileName input-file.tx
getRoot C:

File IO - File.lines
Stream<String> lines = Files.lines("some-path");
● Can use all the cool and powerful Stream methods.
● Lazy evaluation.
● Throws IOException.
● Stream should be closed.
● Stream implements AutoCloseable

File IO - Example
public List<Car> loadCars(Path filePath) {
try (Stream<String> allCars = Files.lines(filePath)) {
return allCars
.filter(car -> hasFourSeats(car))
.filter(carWithFourSeats -> this::isRed)
.map(redCarWithFourSeats -> addDoors(redCarWithFourSeats))
.sorted()
.distinct()
}
}

File IO - Files.write
Files.write(somePath, lines, someCharset, someOption);
Files.write(somePath, fileArray, someOption);
● somePath to file,
● lines e.g. List<String> lines, bytes[] data
● someCharset e.g. StandardCharsets.UTF_8
● someOption e.q. StandardOpenOption.APPEND

Java7 approach
public void savePoems(List<String>
poems) {
File file = new
File("/home/grzegorz/poems.txt");
try (FileWriter fw = new
FileWriter(file)) {
for (String poem: poems) {
fw.write(poem);
}
}
}

Java7 approach
public void savePoems(List<String>
poems) {
File file = new
File("/home/grzegorz/poems.txt");
try (FileWriter fw = new
FileWriter(file)) {
for (String poem: poems) {
fw.write(poem);
}
}
}
Java8 approach
public void savePoems(List<String> poems) {
Path path =
Paths.get("/home/grzegorz/poems.txt");
try {
Files.write(path, poems,
StandardOpenOption.WRITE);
}
}

● Coreservlets.com, Marty Hall - “Java 8 Tutorial”
http://www.coreservlets.com/java-8-tutorial/
● Confitura 2015, Grzegorz Piwowarek - “Lambdas && Monads” (PL)
https://youtu.be/VglEyjgxAKY
More on Java8

You can find our job offers at
xsolve.pl/career
Thank you for your time!
Questions?
Marriage offers?
Free lunch?
team4java@xsolve.pl

Xlab #1: Advantages of functional programming in Java 8

More Related Content

What's hot

Viewers also liked

Similar to Xlab #1: Advantages of functional programming in Java 8

More from XSolve

Recently uploaded

Xlab #1: Advantages of functional programming in Java 8