Common mistakes functional java | Oracle Code One 2018

Common mistakes made
with Functional Java
Brian Vermeer (@BrianVerm)

Brian Vermeer
Software Engineer

Doing too much in a single lambda

Lambda Expression
In computer programming, a lambda expression is a function deﬁnition
that is not bound to an identiﬁer. Anonymous functions are often:[1]
• arguments being passed to higher-order functions, or
• used for constructing the result of a higher-order function that
needs to return a function.

Lambda in Java
Anonymous Inner functions
Satisfy a Functional Interface
They only exist in runtime
Single Line <input> -> <output> or Block <input> -> { function body }

Example
public void execute() {
Beer grolsch = new Beer("Grolsche", 4.3);
String result = handleBeer(grolsch,
beer -> grolsch.getName() + "-" + grolsch.getAlcohol());
System.out.println(result);
}
private String handleBeer(Beer beer, Function<Beer, String> func) {
System.out.println("handling beer " + beer.getName());
return func.apply(beer);
}
//Output : Grolsche-4.3

Don’t do Block Lambda
beer -> {
String name;
if (beer.getName().contains(" ")) {
name = beer.getName().replace(" ", "");
} else {
name = beer.getName();
}
try {
name += Integer.parseInt(beer.getAlcoholPrecentage().toString());
} catch (NumberFormatException nfe) {
name += beer.getAlcoholPrecentage();
}
return name;
}

Transform to a methode
private String createFullName (Beer beer){
String name;
if (beer.getName().contains(" ")) {
name = beer.getName().replace(" ", "");
} else {
name = beer.getName();
}
try {
name += Integer.parseInt(beer.getAlcoholPrecentage().toString());
} catch (NumberFormatException nfe) {
name += beer.getAlcoholPrecentage();
}
return name;
}
handleBeer(grolsch, this::createFullName);

A stream is NOT a
data structure

A stream is NOT a
data structure
A stream is NOT a
data structure

What is Stream ( in Java)
Flow of data derived from a Collection
Can create a pipeline of function that can be evaluated
Intermediate result
Lazy evaluated by nature
Can transform data, cannot mutate data

JAVA Streams
stringLists.stream() 
.map(str -> str.toUpperCase()) 
.collect(Collectors.toList());
Intermediate
filter  
distinct 
map  
flatMap 
Terminal
reduce 
collect 
toArray 
count 
max 
min 
limit  
skip 
sorted 
peek
findAny 
findFirst 
forEach 
allMatch 
anyMatch

List<Beer> beers = getBeers(); 
Stream<Beer> beerStream = beers.stream(); 
 
beerStream.forEach(b ->System.out.println(b.getName())); //1
 
beerStream.forEach(b ->System.out.println(b.getAlcohol())); //2
Only use a Stream once
Line 2 will give:  
 
java.lang.IllegalStateException: stream has already been operated upon or
closed

public Stream<Beer> getMeMyBeers()
getMeMyBeers() //don’t know if it is consumed yet!!!!
…
}
Don’t return a Stream

List<Beer> beers = List.of(new Beer("Heineken", 5.2), new Beer("Delirium
Tremens", 9.0), new Beer("Amstel", 5.1));
beers.stream() 
.limit(10) 
.map(i -> i.getAlcohol()) 
.peek(i -> { 
if (i > 7.0) 
throw new RuntimeException(); 
});
Consume the stream

List<Beer> beers = List.of(new Beer("Heineken", 5.2), new Beer("Delirium
Tremens", 9.0), new Beer("Amstel", 5.1));
beers.stream() 
.limit(10) 
.map(i -> i.getAlcohol()) 
.peek(i -> { 
if (i > 7.0) 
throw new RuntimeException(); 
})
.forEach(System.out::println);
Consume the stream
5.2
Exception in thread "main" java.lang.RuntimeException

Functional Programming
In computer science, functional programming is a programming
paradigma style of building the structure and elements of computer
programs that treats computation as the evaluation of mathematical
functions and avoids changing-state and mutable data.
It is a declarative programming paradigm, which means programming is
done with expressions or declarations instead of statements.
— wikipedia

– Kevlin Henney
“Asking a question should not
change the answer, nor
should asking it twice”

Immutable objects
Less moving parts
Easier to reason about code
No need to keep a mental map of the state an object is in.

Stream cannot mutate
private final List<Beer> beers = List.of(new Beer("Heineken", 5.2),
new Beer("Amstel", 5.1));
List<Beer> beersNew = beers.stream()
.map(beer -> beer.setName(“foo”)) //not allowed
}

Stream should not mutate !
private class Beer {
String name;
Double alcohol;
public Beer setName(String name){
this.name = name;
return this;
}
}
private final List<Beer> beers = List.of(new Beer("Heineken", 5.2), new Beer("Amstel",
5.1));
.map(beer -> beer.setName("foo"))
System.out.println(beers);
System.out.println(beersNew);
}

Return a new copy
String name;
Double alcohol;
public Beer withName(String name){
return new Beer(name, this.alcohol);
}
}
private final List<Beer> beers = List.of(new Beer("Heineken", 5.2), new Beer("Amstel",
5.1));
.map(beer -> beer.withName("foo"))
System.out.println(beers);
System.out.println(beersNew);
}

forEach()
Terminal functional on a stream.
Takes a consumer.
Can be used to apply side effects.
for-loop without the external iterator

simple forEach example
List<String> names = List.of("James", "Trisha", "Joshua",
"Jessica","Simon", “Heather”, “Roberto”);
names.stream()
.map(String::toUpperCase)

mutation with forEach
List<Beer> beers = List.of(new Beer("Heineken", 5.2), new
Beer("Amstel", 5.1));
beers.stream()
.forEach(beer -> beer.setAlcohol(0.0));

overusing forEach
String name;
Double alcohol;
List<String> reviews;
Integer rating;
}
List<Beer> beers = List.of(new Beer("Heineken", 5.2), new Beer("Amstel", 5.1));
//enrich with ratings
beers.stream().forEach(beer -> beer.setRating(findRating(beer.getName())));
//enrich with reviews
beers.stream().forEach(beer -> beer.setReviews(findReviews(beer.getName())));
…

Assignment
Beers -> Brewer -> Country
I want the first 3 unique brewers countries from the beer library as comma separated String
beerLib.stream()
.map(Beer::getBrewer)
.distinct()
.limit(3)
.map(Brewer::getCountry)
.collect(Collectors.joining(“,”));

Assignment
beerLib.stream()
.distinct()
.limit(3)
// wrong

Assignment
beerLib.stream()
.distinct()
.limit(3)
// correct

Infinite stream
IntStream.iterate(0, i -> ( i + 1) % 2) 
.distinct() 
.limit(10) 
.forEach(i -> System.out.println(i));

Infinite stream
.distinct() 
.limit(10) 
.forEach(i -> System.out.println(i)); 
// will run forever
.limit(10) 
.distinct() 
.forEach(i -> System.out.println(i));
//will terminate

Infinite stream
.parallel()
.distinct() 
.limit(10) 
.forEach(i -> System.out.println(i)); 
// will run forever on all threads.

Solution
1. Look closely at the order of operations 
- prevent incorrect answers 
 
2. Only use infinite streams when absolutely necessary.
rather use:  
IntStream.range(0,10);
IntStream.rangeClosed(0,10);
IntStream.iterate(0, i -> i < 10, i -> i + 1); //java 9 and up

Optional
Java’s implementation of the Maybe Monad
Encapsulation to handle possible null value
Consider it a wrapper where a value can be absent
Force the user to unpack the Optional before using it.

Optional
Optional<String> c = null //please avoid this

Optional<String> maybeString = getText();
String unpacked = maybeString.get();
}
Unpack Optional

}
Unpack Optional
NoSuchElementException

}
Unpack Optional
if (maybeString.isPresent()) {
}
}
NoSuchElementException

Unpack Optional
maybeString.ifPresent( str -> /* doSomething */ );
}
maybeString.map(str -> str + “.");
}

Alternative flow
- orElse()
- orElseGet()
- orElseThrow()

orElseThrow
public void execute() { 
Optional<String> maybeString = Optional.empty(); 
maybeString 
.map(this::runIfExist) 
.orElseThrow(() -> new RuntimeException("Optional was empty")); 
}

orElse
Optional<String> maybeString = Optional.of("foo"); 
String newString = maybeString 
.orElse(runIfEmpty()); 
System.out.println(newString); 
} 
private String runIfExist(String str) { 
System.out.println("only run if optional is filled "); 
return str; 
} 
private String runIfEmpty() { 
System.out.println("only run if empty"); 
return "empty"; 
}

orElse
.orElse(runIfEmpty()); 
} 
return str; 
} 
return "empty"; 
}
only run if optional is filled
only run if empty
foo

orElseGet
.orElseGet(() -> runIfEmpty()); 
} 
return str; 
} 
return "empty"; 
}

orElseGet
.orElseGet(() -> runIfEmpty()); 
} 
return str; 
} 
return "empty"; 
}
only run if optional is filled
foo

what else?
- When using orElse(x), make sure x doesn’t contain any side effects
- Only use orElse() to assign a default value
- Use orElseGet() to run an alternative flow

Checked Exceptions & Lambda
public Beer doSomething(Beer beer) throws IsEmptyException { …}
Function <Beer,Beer> fBeer = beer -> doSomething(beer)

beerLib.stream()
.map(beer -> { 
try{ 
return doSomething(beer); 
} catch (IsEmptyException e) { 
throw new RuntimeException(e); 
} 
};)
//not very pretty

private Beer wrappedDoSomeThing(Beer beer) { 
try{ 
return doSomething(beer); 
} catch (IsEmptyException e) { 
throw new RuntimeException(e); 
} 
}
beerLib.stream()
.map(this::wrappedDoSomeThing)

Exception Utility
@FunctionalInterface 
public interface CheckedFunction<T, R> { 
public R apply(T t) throws Exception; 
}
public static <T, R> Function<T, R> wrap(CheckedFunction<T, R> function) { 
return t -> { 
try { 
return function.apply(t); 
} catch (Exception ex) { 
throw new RuntimeException(ex); 
} 
}; 
};
beerLib.stream()
.map(wrap(beer -> doSomething(beer)))

Either type
public class Either<L, R> {
private final L left;
private final R right;
private Either(L left, R right) {
this.left = left;
this.right = right;
}
public static <L,R> Either<L,R> Left( L value) {
return new Either(value, null);
}
public static <L,R> Either<L,R> Right( R value) {
return new Either(null, value);
} …
}

Either type
private Either<Exception, String> canGoWrong(Integer input) {
if (input > 10) {
return Either.Left(new RuntimeException("larger then 10"));
}
return Either.Right("["+input+"]");
}
List<Either<Exception, String>> canGoWrongs = IntStream.range(0,12)
.mapToObj(i -> canGoWrong(i))

Either type
private Either<Exception, String> canGoWrong(Integer input) {
if (input > 10) {
return Either.Left(new RuntimeException("larger then 10"));
}
return Either.Right(“["+input+"]");
}
List<Either<Exception, String>> canGoWrongs = IntStream.range(0,12)
.mapToObj(i -> canGoWrong(i))
canGoWrongs.stream()
.map(e -> e.mapRight(s -> s.toUpperCase()))
.flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))

Try
- Failure (Exception)
- Success (Type)
- VAVR

Try
- Failure (Exception)
- Success (Type)
- VAVR
List<Try<String>> output = teams.stream()
.map(CheckedFunction1.liftTry(this::mayThrowException))

//java 9
List myList = List.of(1,2,3,4,5)
//pre Java9
List myList = Arrays.asList(new String[] {“a”,"b","c"});
Creating collections

//java 9
List myList = List.of(1,2,3,4,5)
//pre Java9
List myList = Arrays.asList(new String[] {"a","b","c"});
// since Java 8
List myList = Stream.of("a","b","c","d").collect(Collectors.toList());
Creating collections

private Beer foo(){...}
private Beer bar(){...}
private Beer fooBar(){…}
Beer myBeer = new Beer();
Beer result = fooBar(bar(foo(myBeer)));
Using Stream.of

private Beer foo(){...}
private Beer bar(){...}
private Beer fooBar(){…}
Beer myBeer = new Beer();
Beer result = fooBar(bar(foo(myBeer)));
Using Stream.of
Beer result = Stream.of(myBeer)
.map(this::foo) 
.map(this::bar) 
.map(this::fooBar) 
.findFirst().get();

String sentence = "The quick fox jumps over the lazy dog. ";
String[] words = sentence
.trim()
.toUpperCase()
.split(" ");
for(String word : words) {
System.out.println(word);
}
Using Stream.of

String sentence = "The quick fox jumps over the lazy dog. ";
String[] words = sentence
.trim()
.toUpperCase()
.split(" ");
for(String word : words) {
System.out.println(word);
}
Stream.of(sentence)
.map(String::trim)
.map(str -> str.split(" "))
.flatMap(array -> Arrays.stream(array))
Using Stream.of

Brian Vermeer
@BrianVerm
brian@brianvermeer.nl

Common mistakes functional java | Oracle Code One 2018

Recommended

More Related Content

What's hot (19)

Similar to Common mistakes functional java | Oracle Code One 2018 (20)

More from Brian Vermeer (11)

Recently uploaded (20)

Common mistakes functional java | Oracle Code One 2018