Project Lambda: Evolution of Java

Project Lambda:
Evolution of Java
Can Pekdemir

“I would say, for most Java developers, it’s revolutionary. For
polyglot programmers, it’s evolutionary”.
Adam Bien - author of Real World Java EE Patterns

Agenda
• Programming paradigms
• Rise of functional programming
• Lambda expressions
• Functional Interface
• Stream API
• Other exciting Java 8 features

Programming Paradigms
• Main programming paradigms
• Imperative programming
• Functional programming
• Logic programming
• Object-Oriented Programming?

Imperative Programming
• Ideas of Von Neumann architecture digital hardware
technology
• First do this and next do that
• Concentrates on how
• Mutable variables
• Assignments, control structures if-then-else, loops, etc.

Imperative Programming
Total of discounted prices by then which are greater than 20.
BigDecimal totalOfDiscountedPrices = BigDecimal.ZERO;
for(BigDecimal price : prices) {
if(price.compareTo(BigDecimal.valueOf(20)) > 0)
totalOfDiscountedPrices =
totalOfDiscountedPrices.add(price.multiply(BigDecimal.valueOf(0.9)));
}
System.out.println("Total of discounted prices: “ +
totalOfDiscountedPrices);

Functional Programming
• Mathematics and the theory of functions
• John Backus:”Can programming be liberated from the von
Neumann Style?”
• Functions are first class citizens.
• Functions can be defined anywhere, inside other functions.
• Functions can be passed as argument.
• Typically avoids mutable state.
• What we want rather than how to do it.

Functional Programming
final BigDecimal totalOfDiscountedPrices = prices.stream()
.filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0)
.map(price -> price.multiply(BigDecimal.valueOf(0.9)))
.reduce(BigDecimal.ZERO, BigDecimal::add);
Declarative style: expressions over statements.

Executionin the Kingdomof Nouns
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("hi " + name);
}});
StateManager.getConsiderationSetter("Noun Oriented Thinking",
State.HARMFUL).run();
Steve Yegge
http://steve-yegge.blogspot.com.tr/2006/03/execution-in-
kingdom-of-nouns.html

The Difference
“OO makes code understandable by encapsulating moving parts.
FP makes code understandable by minimizing moving parts.”
Michael Feathers, author of “Working with legacy code”

Functional Programming Rises
• The rise of multicore CPUs and big data.
• Need for parallel programming with immutable data.
• Declarative programming
• Less clutter code

Java Evolution
• Lack of abstracting over behaviour, not just data
• Parallelism should be free, confusing thread api
• Need for lazy evaluation over data

Behaviour Abstraction
• First requirement: filter green apples
public static List<Apple> filterGreenApples(List<Apple> inventory){
List<Apple> result = new ArrayList<>();
for (Apple apple: inventory){
if ("green".equals(apple.getColor())) {
result.add(apple);
}
}
return result;
}
What if they want to according to “red”!

Behaviour Abstraction
• Abstracting over color
public static List<Apple> filterApplesByColour(List<Apple> inventory,
String color) {
if ( apple.getColor().equals(color) ) {
result.add(apple);
}
}
return result;
}
- What if they want to filter according to weight!

Refactoring?
public static List<Apple> filterApples(List<Apple> inventory, String color, int
weight, boolean flag) {
if ( (flag && apple.getColor().equals(color)) || (!flag &&
apple.getWeight() > weight) ){
result.add(apple);
}
}
return result;
}
List<Apple> greenApples = filterApples(inventory, "green", 0, true);
List<Apple> heavyApples = filterApples(inventory, "", 150, false);

Parameterize Behaviour
ApplePredicate encapsulates a strategy for selecting an apple
public interface ApplePredicate{
boolean test (Apple apple);
}
public class AppleWeightPredicate implements ApplePredicate{
public boolean test(Apple apple){
return apple.getWeight() > 150;
}
}
public class AppleColorPredicate implements ApplePredicate{
return "green".equals(apple.getColor());
} }

Filtering by an Abstract Criterion
public static List<Apple> filterApples(List<Apple> inventory,
ApplePredicate p){
for(Apple apple: inventory){
if(p.test(apple)){
result.add(apple);
}
}
return result;
}

Filter with Anonymous Class
List<Apple> redApples = filterApples(inventory,
new ApplePredicate() {
return "red".equals(a.getColor());
}
});
- Very bulky and confusing to use.

Filter Using Lambda Expression
filterApples(inventory, (Apple apple) ->
"red".equals(apple.getColor()));
"green".equals(apple.getColor()));
apple.getWeight() > 150);

Refactor Design with Generics
public static <T> List<T> filter(List<T> list, Predicate<T> p){
List<T> result = new ArrayList<>();
for(T e: list){
if(p.test(e)){
result.add(e);
}}
return result;
}
List<Apple> redApples = filter(inventory, (Apple apple) ->
"red".equals(apple.getColor()));
List<Integer> evenNumbers = filter(numbers, (Integer i) -> i % 2 == 0);

Real World Examples
Anonymous inner class
inventory.sort(new Comparator<Apple>() {
public int compare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight()); }
});
Lambda
inventory.sort((Apple a1, Apple a2) ->
a1.getWeight().compareTo(a2.getWeight()));
Anonymous inner class
Thread t = new Thread(new Runnable() {
public void run(){
System.out.println("Hello world"); }
});
Lambda
Thread t = new Thread(() -> System.out.println("Hello world"));

Lambda Expressions
• Anonymous function
• Doesn’t have a name
• Has a list of parameters, a body, a return type
(List<String> list) -> list.isEmpty()
() -> new Apple(10)
(Apple a) -> System.out.println(a.getWeight())
(String s) -> s.length()
(int a, int b) -> a * b
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())

Functional Interface
• Lambdas are supported by functional interface
• An interface with single abstract method
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}

java.util.function
• Predefined Functional Interfaces
• Function<T,R> : Takes an object of type T and returns R.
• Supplier<T> : Just returns an object of type T.
• Predicate<T> : returns a boolean value based on type T.
• Consumer<T> : performs an action with given type T.

Predicate
• Defines an abstract method test
Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

Consumer
• Perform some operation on type T
public interface Consumer<T>{
public void accept(T t);
}
public static <T> void forEach(List<T> list, Consumer<T> c){
for(T i: list){
c.accept(i);
}
}
forEach(Arrays.asList(1,2,3,4,5),(Integer i) -> System.out.println(i));

Function
• Defines an abstract method named apply, takes an argument T
and returns of type R.
public interface Function<T, R>{
public R apply(T t);
}
public static <T, R> List<R> map(List<T> list, Function<T, R> f) {
List<R> result = new ArrayList<>();
for(T s: list){
result.add(f.apply(s));
}
return result;
}
List<Integer> l = map(Arrays.asList("lambdas","in","action"), (String s) -> s.length());

Functional Interface for Primitives
• Performance saving from autoboxing with primitive ones.
public interface IntPredicate{
public boolean test(int t);
}
IntPredicate evenNumbers = (int i) -> i % 2 == 0;
evenNumbers.test(1000);
// true (no boxing)
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
oddNumbers.test(1000);
// false (boxing)

Type Interference
• Deduce appropriate signature and target type
List<Apple> greenApples = filter(inventory, (Apple a) ->
"green".equals(a.getColor()));
List<Apple> greenApples = filter(inventory, a -> "green".equals(a.getColor()));
Comparator<Apple> c =(Apple a1, Apple a2) ->
a1.getWeight().compareTo(a2.getWeight());
Comparator<Apple> c = (a1, a2) ->
a1.getWeight().compareTo(a2.getWeight());

Capturing Variables within a Lambda
• The variable should be captured in lambda must be final or
“effectively final”.
int portNumber = 1337;
//error
portNumber = 31338;
Runnable r = () → System.out.println(portNumber);

Method References
• Another syntax for lambda expressions
Lambda Method reference equivalent
(Apple a)-> a.getWeight() Apple::getWeight
()->Thread.currentThread.dumpStack() Thread.currentThread()::dumpStack
(String s) -> System.out.println(s) System.out::println

Stream API
• A sequence of elements from a source that supports
aggregate operations.
• Stream doesn’t hold all data
• Lazily constructed collections
• Uses internal iterations
• Supports parallelism easily.
• java.util.stream

Filter
• Acceps a predicate to filter
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);

Sorted
• Sorted in natural order unless you pass a custom Comparator.
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
//list interface sort method
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));//sort by
weight

Map
• Convert each element into another object.
• Uses Function interface
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))

Reduce
• Perform a reduction on the elements of the stream
List<Integer> numbers = Arrays.asList(3,4,5,1,2);
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
int sum2 = numbers.stream().reduce(0, Integer::sum);
int max = numbers.stream().reduce(0, (a, b) -> Integer.max(a, b));

Match
• returns a boolean
• boolean anyStartsWithA = stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
• anyMatch, allMatch, noneMatch

Other Useful Methods
• distinct > returns a stream of distinct elements
• peek > support debugging of elements
• limit > returns a stream of elements with maxSize
• skip > returns a stream of elements after discarding the first
number of elements of stream.
• min, max, count
• forEach, collect(toList), findFirst, findAny, of
• groupingBy, partitioningBy

Lazy Evaluation
• Lazy intermediate operations: filter, sorted, map,
• Terminal operations: match, count, reduce, collect
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> twoEvenSquares = numbers
.stream()
.filter(n -> n% 2 == 0)
.map(n -> n * n)
.limit(2)
.collect(toList());
System.out.println(twoEvenSquares); // [ 4, 16]

Parallel Stream
• Just use parallelStream method
• We should be careful about the collection size for
performance
List<Apple> greenApples = inventory.parallelStream()
.filter(a -> "green".equals(a.getColor()))
.sorted()
.collect(toList());

Null Reference Problem
• “I call it my billion-dollar mistake. simply because it was so
easy to implement. This has led to innumerable errors,
vulnerabilities, and system crashes, which have probably
caused a billion dollars of pain and damage in the last forty
years.”
Tony Hoare – developed quick sort, ALGOL

Optional Type
Optional<String> reduced = stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);

Optional Type
Optional<String> optional = Optional.of("test");
optional.isPresent(); // true
optional.get(); // "test"
optional.orElse("fallback"); // "test”
optional.ifPresent((s) -> System.out.println(s.charAt(0))); //
"t"

Default Methods
• Also known as virtual extension methods
• Adds methods to interfaces with implementation
• Mainly aimed for backward compatibility
• Multiple inheritance?, difference from abstract class?
interface Iterable<T> {
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
}

New Date API
• Under the package java.time
• Looks like Joda-Time library
• Immutable classes
LocalTime now1 = LocalTime.now();
LocalTime now2 = LocalTime.now();
System.out.println(now1.isBefore(now2)); // false
LocalDate today = LocalDate.now(); //immutable
LocalDate tomorrow = today.plusDays(1);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDateTime localDateTime = LocalDateTime.now();

Nashorn Javascript Engine
• replaces the old Rhino Javascript engine
• competes with Google V8(powers Chrome and Node.js)
• can be executed command-line with jjs tool or
programmatically
• javascript functions can be called from java side

Nashorn Javascript Engine
var fun1 = function(name) {
print('Hi there from Javascript, ' + name);
return "greetings from javascript";
};
ScriptEngine engine = new
ScriptEngineManager().getEngineByName("nashorn");
engine.eval(new FileReader("script.js"));
Invocable invocable = (Invocable) engine;
Object result = invocable.invokeFunction("fun1", ”Liu Kang");

Metaspace
• A new memory space
• Permgen space completely removed
• Allocations for the class metadata are now allocated out of
native memory
• A new flag is available (MaxMetaspaceSize)

References
• https://github.com/java8/Java8InAction
• http://winterbe.com/posts/2014/03/16/java-8-tutorial/
• http://blog.informatech.cr/2013/04/10/java-optional-objects/
• http://viralpatel.net/blogs/java-8-default-methods-tutorial/
• http://steve-yegge.blogspot.com.tr/2006/03/execution-in-kingdom-of-nouns.html
• http://en.wikipedia.org/wiki/Tony_Hoare
• http://winterbe.com/posts/2014/04/05/java8-nashorn-tutorial/
• http://java.dzone.com/articles/java-8-permgen-metaspace
• Subramaniam, Venkat. (2014) Functional Programming in Java: Harnessing the Power Of Java 8 Lambda
Expressions
• Warburton, Richard. (2014) Java 8 Lambdas: Pragmatic Functional Programming
• Urma, Raoul-Gabriel. (2014) Java 8 in Action: Lambdas, Streams and Functional-style Programming

Project Lambda: Evolution of Java

More Related Content

What's hot

Similar to Project Lambda: Evolution of Java

Recently uploaded

Project Lambda: Evolution of Java