When embracing Java 8 we walk down the yellow brick road to the wizard of lambdas. That road usually starts from the fear and terror of learning their syntax until finally getting to understand them and opening our minds to the fruitful fields of functional programming. But this road eventually reaches a final stage: the lambda abuse. To master the lambdas art means to know when to use them and when not to not damage your brain and, most importantly, other Java developers’. Keep your code readable and maintainable, avoid becoming a lambda addict!

1. The… Wonderful? World of
Lambdas
David Gómez
@dgomezg
Esther Lozano
@esloho

2. Parameterized
behaviour
It’s cool!!
More concise
code
Become a
Functional
Programmer in Java

3. Packing the backpack

4. A real chat
Just saw a simple and
useful case for lambdas:
better logging!

5. A real chat
Just saw a simple and
useful case for lambdas:
better logging!
A new Object
instance for each log
statement… isn’t it a
bit overkill?

6. Not sugar syntax
public class SimpleInnerClassUse {
public void executeAction(Action action) {
action.execute();
}
public static void main (String ... args) {
new SimpleInnerClassUse().executeAction(new Action() {
@Override
public void execute() {
System.out.println("Action Executed (Inner class)");
}
});
}
}

7. Not sugar syntax
public static void main (String ... args) {
new SimpleInnerClassUse().executeAction(new Action() {
@Override
public void execute() {
System.out.println("Action Executed (Inner class)");
}public static void main(java.lang.String...);
flags: ACC_PUBLIC, ACC_STATIC, ACC_VARARGS
Code:
stack=3, locals=1, args_size=1
0: new #3 // class com/autentia/training/java8/lambdas/SimpleInnerClassUse
3: dup
4: invokespecial #4 // Method "<init>":()V
7: new #5 // class com/autentia/training/java8/lambdas/SimpleInnerClassUse$1
10: dup
11: invokespecial #6 // Method
com/autentia/training/java8/lambdas/SimpleInnerClassUse$1."<init>":()V
14: invokevirtual #7 // Method
executeAction:(Lcom/autentia/training/java8/functionalinterfaces/Action;)V
17: return

8. Not sugar syntax
public class SimpleLambdaUse {
public void executeAction(Action action) {
action.execute();
}
public static void main (String ... args) {
new SimpleLambdaUse().executeAction(
()-> System.out.println("action executed!"));
}
}

9. Not sugar syntax
public static void main (String ... args) {
new SimpleLambdaUse().executeAction(
()-> System.out.println("action executed!"));
}
public static void main(java.lang.String...);
flags: ACC_PUBLIC, ACC_STATIC, ACC_VARARGS
Code:
stack=2, locals=1, args_size=1
0: new #3 // class
com/autentia/training/java8/lambdas/SimpleLambdaUse
3: dup
4: invokespecial #4 // Method "<init>":()V
7: invokedynamic #5, 0 // InvokeDynamic
#0:execute:()Lcom/autentia/training/java8/functionalinterfaces/Action;
12: invokevirtual #6 // Method
executeAction:(Lcom/autentia/training/java8/functionalinterfaces/Action;)V
15: return

10. Not sugar syntax
Less impact in ClassLoader, Memory & GC
$ ls -la com/autentia/training/java8/lambdas/*.class
com/autentia/training/java8/lambdas/SimpleInnerClassUse$1.class
com/autentia/training/java8/lambdas/SimpleInnerClassUse.class
com/autentia/training/java8/lambdas/SimpleLambdaUse.class

11. Not so new: SAM Types & @FunctionalInterface
Have you ever used…?
public interface Runnable {
public abstract void run();
}

12. Not so new: SAM Types & @FunctionalInterface
Have you ever used…?
public interface Runnable {
public abstract void run();
}
Single Abstract Method (SAM type)

13. Not so new: SAM Types & @FunctionalInterface
Have you ever used…?
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
Single Abstract Method (SAM type)
Functional Interface

14. From imperative to declarative
Imperative code:
List<Integer> numbers = //List of random numbers
List<Integer> evenNumbers = new ArrayList<>();
for (int i : numbers) {
if (i % 2 == 0) {
evenNumbers.add(i);
}
}

15. From imperative to declarative
Declarative code:
List<Integer> numbers = //List of random numbers
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(toList());

16. From imperative to declarative
More concise:
phoneCallLog.stream()
.filter(phoneCall ->
phoneCall.getTime().getMonth() == Month.JUNE)
.map(phoneCall -> phoneCall.getContact().getName())
.distinct()
.forEach(System.out::println);

17. Lambdas & its context
public class SimpleInnerClassUse {
public static void main (String ... args) {
new SimpleInnerClassUse().executeAction(new Action() {
public String whoAmI() {
return this.getClass().getName();
}
@Override
public void execute() {
System.out.println("I am " + this.whoAmI());
}
});
}
}

18. Lambdas & its context
public class SimpleInnerClassUse {
public static void main (String ... args) {
new SimpleInnerClassUse().executeAction(new Action() {
public String whoAmI() {
return this.getClass().getName();
}
@Override
public void execute() {
System.out.println("I am " + this.whoAmI());
}
});
}
}

19. Lambdas & its context
public class SimpleInnerClassUse {
public static void main (String ... args) {
new SimpleInnerClassUse().executeAction(new Action() {
public String whoAmI() {
return this.getClass().getName();
}
@Override
public void execute() {
System.out.println("I am " + this.whoAmI());
}
});
}
}
I am com.autentia.training.java8.lambdas.SimpleInnerClassUse$1

20. Lambdas & its context
public class SimpleLambdaUse {
public static void main (String ... args) {
new SimpleLambdaUse().invokeFromInstance();
}
public void invokeFromInstance() {
executeAction(() -> System.out.println("I am " + this.whoAmI()));
}
public String whoAmI() {
return SimpleLambdaUse.class.getSimpleName();
}
}

21. public class SimpleLambdaUse {
public static void main (String ... args) {
new SimpleLambdaUse().invokeFromInstance();
}
public void invokeFromInstance() {
executeAction(() -> System.out.println("I am " + this.whoAmI()));
}
public String whoAmI() {
return this.getClass().getSimpleName();
}
}
Lambdas & its context

22. public class SimpleLambdaUse {
public static void main (String ... args) {
new SimpleLambdaUse().invokeFromInstance();
}
public void invokeFromInstance() {
executeAction(() -> System.out.println("I am " + this.whoAmI()));
}
public String whoAmI() {
return this.getClass().getSimpleName();
}
}
Lambdas & its context: this & super
I am SimpleLambdaUse

23. Lambdas & its context
● Variable capture? Use variable inherited from context?
○ Stateless lambdas
()->System.out.println("Doing Stuff...")
○ Capturing lambdas
() -> System.out.println(seeds[Math.round(Math.random()*10)])

24. Hit the road!

25. The slopes of anonymous inner classes
● First use case: lambdas as replacement for anonymous inner classes
ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.submit(
new Runnable() {
@Override
public void run() {
System.out.println("doing stuff...");
}
}
);
() -> void

26. The slopes of anonymous inner classes
● First use case: lambdas as replacement for anonymous inner classes
ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.submit(()->System.out.println("Doing Stuff..."));
() -> void

27. The fields of java.util.function
Do you remember?
@FunctionalInterface
public interface Runnable {
public abstract void run();
}

28. The fields of java.util.function

29. The fields of java.util.function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
Function<RowSet, Contact> contactJdbcMapper = row -> {
Contact c = new Contact();
c.setName(row.getString(0));
...
return c;
}

30. The fields of java.util.function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
Function<RowSet, Contact> contactJdbcMapper = row -> new Contact(row);

31. The fields of java.util.function
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
Function<RowSet, Contact> contactJdbcMapper = Contact::new;

32. The meadows of method parameters
● Parameterized behaviour → lazy usage → logging crazy example
public void log(Level level, String msg) {
if (!isLoggable(level)) {
return;
}
LogRecord lr = new LogRecord(level, msg);
doLog(lr);
}
Logger log = Logger.getLogger(LoggingCrazy.class.getSimpleName());
log.log(Level.FINE, heavyObject.expensiveToStringConversion());

33. The meadows of method parameters
● Parameterized behaviour → lazy usage → logging crazy example
public void log(Level level, Supplier<String> msgSupplier) {
if (!isLoggable(level)) {
return;
}
LogRecord lr = new LogRecord(level, msgSupplier.get());
doLog(lr);
}
Logger log = Logger.getLogger(LoggingCrazy.class.getSimpleName());
log.log(Level.FINE, () -> heavyObject.expensiveToStringConversion()

34. The meadows of method parameters
● Parameterized behaviour → lazy usage → logging crazy example
log.log(Level.FINE, heavyObject.expensiveToStringConversion());
log.log(Level.FINE, () -> heavyObject.expensiveToStringConversion());
time logging 100_000_000 times without supplier 10689 ms
time logging 100_000_000 times with supplier 102 ms

35. The loch of function composition
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}

36. The loch of function composition
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
}

37. The loch of function composition
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
}

38. The loch of function composition
new OrderPriceCalculator()
.andThen( Taxes::generalTax )
.andThen( Carrier::shippingCost )
.andThen( Customer::profileDiscount )
.apply( order );

39. The cliffs of Function Return
You can return functions instead of values (lazy evaluation of return values)
public BiFunction<Integer, Integer, Integer> lazyMultiplier(int val1, int val2) {
return (x,y) -> val1*val2;
}

40. Now you feel like a cool FP

41. Abusing lambdas

42. Abusing lambdas: Breaking effectively final rule
public class CapturingLambdas {
private int[] seeds = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
private int[] calculatedValue = new int[1];
public void calculate() {
ExecutorService threadPool = Executors.newFixedThreadPool(2);
threadPool.execute(() -> calculatedValue[0] = seeds[Math.round(Math.random()*10));
}
}

43. Performance un-improvement
throw new RuntimeException(
"Two or more components with same type."
+ " Please use @Named to select one. Candidates: "
+ candidateNames.toString() );

44. Performance un-improvement
throw new RuntimeException(
"Two or more components with same type."
+ " Please use @Named to select one. Candidates: "
+ candidateNames.toString() );
java.lang.RuntimeException: Two or more components with the
same type. Please use @Named to select one. Candidates:
[Ljava.lang.String;@65f1fa47

45. Performance un-improvement
throw new RuntimeException(
"Two or more components with same type."
+ " Please use @Named to select one. Candidates: "
+ Arrays.asList(candidateNames)
.stream().collect(joining(",", "[", "]")));

46. Performance un-improvement
throw new RuntimeException(
"Two or more components with same type."
+ " Please use @Named to select one. Candidates: "
+ Arrays.asList(candidateNames)
.stream().collect(joining(",", "[", "]")));
java.lang.RuntimeException: Two or more components with the
same type. Please use @Named to select one. Candidates:
[Component1, Component2, Component3]

47. Performance un-improvement
Arrays.asList(candidateNames)
.stream().collect(joining(",", "[", "]")));
87 ms
(1000 iter)
StringBuilder sb = new StringBuilder( "[");
for (String candidate : candidates) {
if (sb.length()> 1) {
sb.append( ",");
}
sb.append(candidate);
}
Return sb.append("]").toString();
4 ms
(1000 iter)

48. Optionals
return Optional
.ofNullable(eventConsumers.get(eventType))
.orElseThrow(() ->
new EventConsumerNotFoundException(
"Consumer for event type '" + channel
+ "' has not been found."));

49. Lambdas gone wild
@Override
public String deserializeResult(Parser parser) {
Node root = new ObjectMapper().read(parser);
if (root.size() > 0) {
Node result = root.get(0).get("result");
if (result != null) {
return result.asText();
} else {
return null;
}
} else {
return null;
}
}

50. Lambdas gone wild
@Override
public String deserializeMessage(Parser parser) {
Node root = new ObjectMapper().read(parser);
if (root.size() > 0) {
return Optional.ofNullable(root.get(0).get("result"))
.map(result -> result.asText())
.orElse(null);
} else {
return null;
}
}

51. Lambdas gone wild
@Override
public String deserializeMessage(Parser parser) {
Node root = new ObjectMapper().read(parser);
if (root.size() > 0) {
return Optional.ofNullable(root.get(0).get("result"))
.map(Node::asText)
.orElse(null);
} else {
return null;
}
}

52. Lambdas gone wild
Can we get rid of that extra check?
public String deserializeMessage(Parser parser) {
Node root = new ObjectMapper().read(parser);
return Stream.of(Optional.ofNullable(root.get(0)))
.filter(Optional::isPresent)
.map(Optional::get)
.map(resultNode -> Optional.ofNullable(resultNode.get("result")))
.filter(Optional::isPresent)
.map(JsonNode::asText)
.findFirst()
.orElse(null);
}

53. Lambdas gone wild
public String deserializeMessage(Parser parser) {
return Stream.of(Optional.ofNullable(new ObjectMapper().read(parser).get(0)))
.filter(Optional::isPresent)
.map(Optional::get)
.map(resultNode -> Optional.ofNullable(resultNode.get("result")))
.filter(Optional::isPresent)
.map(JsonNode::asText)
.findFirst()
.orElse(null);
}

54. Lambdas gone wild
After peer review, we decided to get back to:
@Override
public String deserializeMessage(Parser parser) {
Node root = new ObjectMapper().read(parser);
if (root.size() > 0) {
return Optional.ofNullable(root.get(0).get("result"))
.map(Node::asText)
.orElse(null);
} else {
return null;
}
}
Although we could have tried to split the lambda in several methods.

55. Playing with FP concepts
We start with a simple adder function
private BiFunction<Integer, Integer, Integer> adder = (x, y) -> x+y;
We need several other incrementers by a fixed value
private Function<Integer, Integer> incrementByOne = x -> x+1;
private Function<Integer, Integer> incrementByTwo = x -> x+2;
private Function<Integer, Integer> incrementByThree = x -> x+3;

56. Playing with FP concepts
We start with a simple adder function
private BiFunction<Integer, Integer, Integer> adder = (x, y) -> x+y;
We need several other incrementers by a fixed value
private Function<Integer, Integer> incrementByOne = x -> x+1;
private Function<Integer, Integer> incrementByTwo = x -> x+2;
private Function<Integer, Integer> incrementByThree = x -> x+3;

57. Playing with FP concepts
Maybe I can abstract this a little bit:
//Curryfying the increment Function
private Function<Integer, Function<Integer,Integer>> incrementBy = y -> x -> x+y;
So, I can rewrite the incrementers:
private Function<Integer, Integer> incrementByOne = x -> incrementBy.apply(1).apply(x);
private Function<Integer, Integer> incrementByTwo = x -> incrementBy.apply(2).apply(x);
private Function<Integer, Integer> incrementByThree = x -> incrementBy.apply(3).apply(x);

58. Playing with FP concepts
Wait, I can abstract (again) the incrementBy:
private Function<Integer, Integer> incrementByOne = x -> incrementBy.apply(1).apply(x);
private Function<Integer, Integer> incrementByTwo = x -> incrementBy.apply(2).apply(x);
private Function<Integer, Integer> incrementByThree =
x -> incrementBy.apply(3).apply(x);
…..
private BiFunction<Integer, Integer, Integer> sum =
(x,y) -> incrementBy.apply(x).apply(y);
Which is the base:
private BiFunction<Integer, Integer, Integer> sum = (x,y) -> x+y;

59. Playing with FP concepts
From
private Function<Integer, Integer> incrementByOne = x -> incrementBy.apply(1).apply(x);
Can be simplified as (there is a redundant function)
private Function<Integer, Integer> incrementByOne = x -> incrementBy.apply(1);
private Function<Integer, Integer> incrementByTwo = x -> incrementBy.apply(2);
private Function<Integer, Integer> incrementByThree = x -> incrementBy.apply(3);

60. Conclusions
● Simplicity vs performance
● Don’t over use: Conciseness means short and readable! Not only short
● Step back and ask a colleague to read and understand your code

61. Ready to take the road to
the world of lambdas?

62. Better take the road to http://Lambda.World

63. David Gómez
@dgomezg
Esther Lozano
@esloho
The… Wonderful? World of
Lambdas