Learning Java 8, Lambda

Preparation for OCJP8 Exam

Andy Chu

OCJP 8 Upgrade Exam Topic

http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=5001&get_params=p_exam_id:1Z0-810

Overview

Lambda Expression
Using Built in Lambda Types
Filtering Collections with Lambdas
Collection Operation with Lambda
Parallel Streams
Lambda Cookbook
Method Enhancements
Use Java SE 8 Date/Time API
JavaScript on Java with Nashorn

Lambda Expression

Describe/use Java Inner Class
Define/write functional Interface
Refactor code from anonymous inner class to lambda expression

Describe/use Java Inner Class

// filename: OuterClass.java
public class OuterClass {
	
	static class InnerClass{}
	
	class InnerClass2{}
	
	public void doStuff(Object obj){
		class InnerClass3{}
	}
	
	public static void main(String[] args){
		new OuterClass().doStuff(new InnerClass4(){});
	}
}

class InnerClass4{}

static class InnerClass5{}

private class InnerClass6{}

Which line(s) causes error?

Describe/use Java Inner Class

public static void main(String[] args){
	new OuterClass().doStuff(new InnerClass4(){});
	new InnerClass();
	new OuterClass().new InnerClass2();
	new InnerClass4();
}

Which line(s) causes error?

Describe/use Java Inner Class

public class EffecivelyFinal {
	
	interface InnerClass{void print();}
	public void doStuff(InnerClass o){}
	
	public static void main(String[] args){
		final int x = 5;
		int y = 10;
		new EffecivelyFinal().doStuff(new InnerClass() {
			@Override
			public void print() {
				System.out.println(x);
				System.out.println(y);
			}
		});
		y = 15;
		new EffecivelyFinal().doStuff(new InnerClass() {
			@Override
			public void print() {
				System.out.println(y);
			}
		});
	}
}

Which line(s) causes error?

Define/write functional Interface

what is interface
interface vs abstract
when to use interface
interface vs functional interface
when to use functional interface

Define/write functional Interface

functional interface

similar as interface
but only accept single public abstract method

@FunctionalInterface
public interface FuncInterface {
	void method();
	default void func(){}
}

Define/write functional Interface

public class FuncInterfaceEx {
	
	interface Foo{ void foo(); }
	
	@FunctionalInterface
	interface Foo2{ void foo(); }
	
	@FunctionalInterface
	interface Foo3{ static void foo();}
	
	@FunctionalInterface
	interface Foo4 extends Foo3{ void foo();}
	
	@FunctionalInterface
	interface Foo5 { default void foo(){};}
	
	@FunctionalInterface
	interface Foo6 extends Foo5 { void foo();}
	
	interface Foo7 { default void foo();}
	
	@FunctionalInterface
	interface Foo8 extends Foo6 { void foo();}
	
}

Which line(s) causes error?

Refactor code from anonymous inner class to lambda expression

What is lambda??

y = f(x) = x + 1

if x = 0 ... 9

then y = 1...10

anonymous class

Refactor code from anonymous inner class to lambda expression

interface OnWhateverListener{ void onWhatever(); }
	
public void doStuff(OnWhateverListener listener){
	listener.onWhatever();
}
	
public static void main(String[] args){
	new AnonymousClass().doStuff(new OnWhateverListener() {
		@Override
		public void onWhatever() {
			// do whatever stuff
		}
	});
}

anonymous class

public static void main(String[] args) {
	new AnonymousClass().doStuff(() -> {
		// do whatever stuff
		});
}

lambda expression

Refactor code from anonymous inner class to lambda expression

f(x) = x + 1

new AnonymousClass().doStuff(new OnWhateverListener() {
	@Override
	public void onWhatever() {
		// do whatever stuff
	}
});

new Thread(new Runnable() {
	@Override
	public void run() {
		// do something
	}
});

INPUT

OUTPUT

Functional Interface

anonymous class

Refactor code from anonymous inner class to lambda expression

@FunctionalInterface 
interface NoArg{ void foo(); }

Functional Interface

Anonymous class

as Lambda expression

() -> System.out.println("")

@FunctionalInterface 
interface OneArg{ void foo(String s); }

s -> System.out.println(s)

s -> {
    s = s.trim();
    System.out.println(s);
}

@FunctionalInterface 
interface TwoArg{ void foo(int x, int y); }

(x, y) -> x + y

(int x, int y) -> x + y

Refactor code from anonymous inner class to lambda expression

public class LambdaEx {
	@FunctionalInterface 
	interface NoArg{ void foo(); }

	@FunctionalInterface 
	interface OneArg{ void foo(String s); }
	
	@FunctionalInterface 
	interface TwoArg{ void foo(int x, int y); }
	
	public void perform(NoArg foo){}
	public void perform(TwoArg foo){}
	public void perform(OneArg foo){}

	public static void main(String[] args) {
		LambdaEx obj = new LambdaEx();
		obj.perform(()->System.out.println(""));
		obj.perform(s->System.out.println(s));
		obj.perform((x,y)->System.out.println(x+y));
		obj.perform((int x,int y)->System.out.println(x+y));
	}

}

Refactor code from anonymous inner class to lambda expression

Think of

JavaScript call, apply functions

Android observer pattern

Thread runnable

Concurrent Future callable

Reactive programming

Strategy pattern

Command object / pattern

Spring IoC

Reference

http://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
http://en.wikipedia.org/wiki/Anonymous_function#Java
http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html
http://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8
http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Using Built in Lambda Types

Describe java.util.function package
Develop/uses
- Function interface
- Consumer interface
- Supplier interface
- UnaryOperator interface
- Predicate interface
Develop/use primitive and binary variations of base interface
Develop/use method reference

java.util.function package

INPUT

OUTPUT

Functional Interface

Void

Consumer

n/a

Suppiler

Function

boolean

Predicate

UnaryOperator

T, T

BinaryOperator

anonymous class

java.util.function package

Void

Consumer

public class ConsumerEx{
	
	interface Consumer<T>{
		void perform(T t);
	}
	public void doStuff(Consumer<String> c){}
	
	public void withJava() {
		doStuff(new Consumer<String>(){
			@Override
			public void perform(String t) {
				System.out.println(t);
			}
		});
	}
	public void withJava8() {
		doStuff(s -> System.out.println(s.toLowerCase()));
		doStuff(s -> System.out.println(s.toUpperCase()));
	}
}

java.util.function package

n/a

Supplier

public class SupplierEx{
	
	interface Supplier<T>{
		T perform();
	}
	public void doStuff(Supplier<String> s){
		System.out.println(s.perform());
	}
	
	public void withJava() {
		doStuff(new Supplier<String>(){
			@Override
			public String perform() {
				return "Hello World";
			}
		});
	}
	public void withJava8() {
		doStuff(() -> "Hello World".toLowerCase());
		doStuff(() -> {return "Hello World".toUpperCase();});
	}
}

java.util.function package

boolean

Predicate

public class PredicateEx{
	
	interface Predicate<T>{
		boolean perform(T t);
	}
	public void doStuff(Predicate<String> p){
		String s = "something";
		if(p.perform(s)){System.out.println("do" + s);}
	}
	
	public void withJava() {
		doStuff(new Predicate<String>(){
			@Override
			public boolean perform(String s) {
				return s != null;
			}
		});
	}
	public void withJava8() {
		doStuff(s -> s != null);
	}
}

java.util.function package

Function

public class FunctionEx{
	
	interface Function<T, R>{
		R perform(T t);
	}
	public void doStuff(Function<Integer, String> f){
		System.out.println(f.perform((int)Math.random() * 100));
	}
	
	public void withJava() {
		doStuff(new Function<Integer, String>(){
			@Override
			public String perform(Integer s) {
				if(s >= 60) return "pass";
				else return "fail";
			}
		});
	}
	public void withJava8() {
		doStuff(score -> {
			if(score >= 80) return "pass";
			else return "fail";
		});
	}
}

java.util.function package

UnaryOperator

public class UnaryOpEx{
	
	interface UnaryOp<T>{
		T perform(T t);
	}
	public void doStuff(UnaryOp<String> u){
		System.out.println(u.perform("something"));
	}
	
	public void withJava() {
		doStuff(new UnaryOp<String>(){
			@Override
			public String perform(String s) {
				return "baked " + s;
			}
		});
	}
	public void withJava8() {
		doStuff(s -> "baked " + s);
		doStuff(s -> "eat " + s);
	}
}

java.util.function package

T, T

BinaryOperator

public class BinaryOpEx{
	
	interface BinaryOp<T>{
		T perform(T t, T t2);
	}
	public void doStuff(BinaryOp<Integer> b){
		System.out.println(b.perform(2, 1));
	}
	
	public void withJava() {
		doStuff(new BinaryOp<Integer>(){
			@Override
			public Integer perform(Integer a, Integer b) {
				return a + b;
			}
		});
	}
	public void withJava8() {
		doStuff((a, b) -> a * b);
		doStuff((a, b) -> a - b);
	}
}

java.util.function package

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

Develop/use primitive and binary variations of base interface

Function descriptor

T -> boolean

int -> boolean

double -> boolean

T -> R

int -> R

T -> int

Function Interface

Predicate<T>

IntPredicate

DoublePredicate

Function<T, R>

IntFunction<R>

ToIntFunction<T>

Develop/use primitive and binary variations of base interface

Predicate<Integer> vs IntPredicate
Java 1.5 introduce autoboxing, unboxing
autoboxing : int -> Integer
unboxing: Integer -> int

Develop/use primitive and binary variations of base interface

public class IntPredicateEx{
	
	interface IntPredicate extends Predicate<Integer>{
		boolean perform(int t);
	}
	public void doStuff(IntPredicate p){
		if(p.perform((int) Math.random() * 10)){
			System.out.println("Hello World");
		}
	}
	public void withJava() {
		doStuff(new IntPredicate(){
			@Override
			public boolean perform(int t) {
				return false;
			}
		});
	}
	public void withJava8() {
		doStuff(n -> true);
	}
}

Which line(s) causes error? How to correct?

Develop/use primitive and binary variations of base interface

public class IntPredicateEx{
	
        // this is not functional interface
	interface IntPredicate extends Predicate<Integer>{
		boolean perform(int t);
	}
	public void doStuff(IntPredicate p){
		if(p.perform((int) Math.random() * 10)){
			System.out.println("Hello World");
		}
	}
	public void withJava() {
                // needs to implement both because of autoboxing/unboxing 
		doStuff(new IntPredicate(){
			@Override
			public boolean perform(int t) {
				return false;
			}
                        @Override
			public boolean perform(Integer t) {
				return false;
			}
		});
	}
	public void withJava8() {
		doStuff(n -> true); // can't compile
	}
}

Develop/use method reference

ClassName::staticMethodName

// ClassName::staticMethodName
IntFunction<String> f = n -> String.valueOf(n);
IntFunction<String> f = String::valueOf;

// ClassName::new
Supplier<String> f = () -> new String();
Supplier<String> f = String::new;

// ClassName::instanceMethodName
UnaryOperator<String> f = s -> s.trim();
UnaryOperator<String> f = String::trim;

ClassName::new

ClassName::instanceMethodName

// object::instanceMethodName
Integer i = new Integer(1);
Supplier<String> f = () -> i.toString();
Supplier<String> f = i::toString;

object::instanceMethodName

Reference

http://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

Filtering Collections with Lambdas

Develop/uses code that iterates a collection by using forEach
Describe the Stream interface and pipelines
Filter a collection using lambda expression
Identify lambda operation that are lazy

Develop/uses code that iterates a collection by using forEach

public class Apple {
	private String color;
	private int calory;
	
	public Apple(){
		this.color = "red";
		this.calory = 300;
	}
	
	public Apple(String color) {
		this.color = color;
		this.calory = 300;
	}
	
	public Apple(String color, int calory) {
		this.color = color;
		this.calory = calory;
	}
	
	public String getColor(){
		return color;
	}
	
	public int getCalory(){
		return calory;
	}
}

Apple.java

Develop/uses code that iterates a collection by using forEach

public class ExternalIteration{
	List<Apple> apples = new ArrayList<Apple>();
	
	public ExternalIteration(){
		apples.add(new Apple("green"));
		apples.add(new Apple("red"));
		apples.add(new Apple("red"));
	}
	
	public void withJava() {
		for(Apple apple : apples){
			if("green".equals(apple)){
				System.out.println("I found green apple.");
			}
		}
	}
}

(Active) External iteration

Develop/uses code that iterates a collection by using forEach

public class InternalIteration{
	List<Apple> apples = new ArrayList<Apple>();
	
	public InternalIteration(){
		apples.add(new Apple("green"));
		apples.add(new Apple("red"));
		apples.add(new Apple("red"));
	}
	
	public void withJava8(Consumer<Apple> c) {
		for(Apple apple : apples){
			c.accept(apple);
		}
	}
	
	public void doStuff(){
		withJava8(apple -> {
			if("green".equals(apple)){
				System.out.println("I found green apple.");
			}
		});
	}
}

(passive) Internal iteration

Develop/uses code that iterates a collection by using forEach

public interface Iterable<T> {
    public Iterator<T> iterator();
}

Java 5

public interface Iterable<T extends Object> {

    public Iterator<T> iterator();

    public default void forEach(Consumer<? super T> cnsmr) {
        // ...
    }

    ...
}

Java 8

Develop/uses code that iterates a collection by using forEach

public class Iteration{
	List<Apple> apples = new ArrayList<Apple>();
	
	public Iteration(){
		apples.add(new Apple("green"));
		apples.add(new Apple("red"));
		apples.add(new Apple("red"));
	}
	
	public void withJava8() {
		apples.forEach(apple -> {
			if("green".equals(apple)){
				System.out.println("I found green apple.");
			}
		});
	}
}

Collection, List, Set, Map

Describe the Stream interface and pipelines

public class Pipeline{
	List<Apple> apples = new ArrayList<Apple>();
	
	public Pipeline(){
		apples.add(new Apple("green", 200));
		apples.add(new Apple("red", 300));
		apples.add(new Apple("red",50));
	}
	
	public void withJava() {
		List<Apple> redApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if("red".equals(apple)){
				redApples.add(apple);
			}
		}

		List<Apple> lowFatRedApples = new ArrayList<Apple>();
		for(Apple apple : redApples){
			if(apple.getCalory() < 100){
				lowFatRedApples.add(apple);
			}
		}
	}
}

Find low fat and red apples

Describe the Stream interface and pipelines

public class Pipeline2{
	...
	
	public List<Apple> findRedApples(List<Apple> apples) {
		List<Apple> redApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if("red".equals(apple)){
				redApples.add(apple);
			}
		}
		return redApples;
	}
	
	public List<Apple> findLowFatApples(List<Apple> apples) {
		List<Apple> lowFatRedApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if(apple.getCalory() < 100){
				lowFatRedApples.add(apple);
			}
		}
		return lowFatRedApples;
	}
	
	public List<Apple> findLowFatAndRedApples(List<Apple> apples) {
		return findLowFatAndRedApples(findRedApples(apples));
	}
}

What pattern do you see here ?

Describe the Stream interface and pipelines

public class Pipeline3{
	...
	
	public Pipeline3 findRedApples() {
		List<Apple> redApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if("red".equals(apple)){
				redApples.add(apple);
			}
		}
		apples = redApples;
		return this;
	}
	
	public Pipeline3 findLowFatApples() {
		List<Apple> lowFatRedApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if(apple.getCalory() < 100){
				lowFatRedApples.add(apple);
			}
		}
		apples = lowFatRedApples;
		return this;
	}
	
	public List<Apple> getApples(){return apples;}
	
	public static void main(String[] args) {
		new Pipeline3()
				.findLowFatApples()
				.findRedApples()
				.getApples();
	}
}

Builder / Decoration Pattern

Describe the Stream interface and pipelines

public class Pipeline4{
	...
	
	public Pipeline4 filter(Predicate<Apple> p) {
		List<Apple> redApples = new ArrayList<Apple>();
		for(Apple apple : apples){
			if(p.test(apple)){
				redApples.add(apple);
			}
		}
		apples = redApples;
		return this;
	}
	
	public List<Apple> getApples(){return apples;}
	
	public static void main(String[] args) {
		new Pipeline4()
		    .filter(apple -> "red".equals(apple))
                    .filter(apple -> apple.getCalory() < 100)
		    .getApples();
	}
}

What else do you see here?

Filter a collection using lambda expression

http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

Stream Interface

public class Pipeline5{
	...

	public List<Apple> findLowFatAndRedApples(){
		return apples.stream()
				.filter(apple -> "red".equals(apple))
				.filter(apple -> apple.getCalory() < 100)
				.collect(Collectors.toList());
	}
	
	public static void main(String[] args) {
		new Pipeline5().findLowFatAndRedApples();
	}
}

Identify lambda operation that are lazy

Operation returns Stream => Lazy

Stream<Apple> s = sapples.stream()
                            .filter(apple -> {
                                System.out.println("Log");
                                return "red".equals(apple)
                            })  // lazy

List<Apple> redApples = apples.stream()
                            .filter(apple -> {
                                System.out.println("Log");
                                return "red".equals(apple)
                            })
                            .collect(Collectors.toList()); // eager

Operation returns something or void => Eager