Free your Lambdas Java SE 8

Transcription

1 Free your Lambdas Java SE 8

2 Agenda Tutorial session: we will start at the very beginning! and explore how to build functional interfaces to design new APIs This is about lambdas and functional interfaces So not much about Streams & Collectors

3

4 start

5

6 Questions?

7 A first example What is this code doing? Comparator<Person> cmp = new Comparator<Person>() { public int compare(person p1, Person p2) { return p1.getlastname().compareto(p2.getlastname()); }

8 A first example What is this code doing? Comparator<Person> cmp = new Comparator<Person>() { public int compare(person p1, Person p2) { int cmp = p1.getlastname().compareto(p2.getlastname()); if (cmp == 0) { return p1.getfirstname().compareto(p2.getfirstname()); } else { return cmp; } }

9 A first example What is this code doing? Comparator<Person> cmp = new Comparator<Person>() public int compare(person p1, Person p2) { int cmp = p1.getlastname().compareto(p2.getlastname()); if (cmp == 0) { cmp = p1.getlastname().compareto(p2.getfirstname()); if (cmp == 0) { return p1.getage() - p2.getage(); } else { return cmp; } } else { return cmp; } } };

10 A first example What is this code doing? Comparator<Person> cmp = new Comparator<Person>() public int compare(person p1, Person p2) { int cmp = p1.getlastname().compareto(p2.getlastname()); if (cmp == 0) { cmp = p1.getfirstname().compareto(p2.getfirstname()); if (cmp == 0) { return p1.getage() - p2.getage(); } else { return cmp; } } else { return cmp; } } };

11 A first example What is this code doing? Comparator<Person> cmp = Comparator.comparing(Person::getLastName).thenComparing(Person::getFirstName).thenComparing(Person::getAge);

12 A closer look at the Comparator Suppose we want to sort strings of characters 1) We create a comparator: Comparator<String> comparator = new Comparator<String>() { public int compare(string s1, String s2) { return Integer.compare(s1.length(), s2.length()); } };

13 A closer look at the Comparator Suppose we want to sort strings of characters 1) We create a comparator: Comparator<String> comparator = new Comparator<String>() { public int compare(string s1, String s2) { return Integer.compare(s1.length(), s2.length()); } }; 2) We pass it to the right method: Arrays.sort(strings, comparator); Collections.sort(list, comparator) ;

14 A closer look at the Comparator What did we do?

15 A closer look at the Comparator What did we do? We passed a piece of code as a parameter to a method And this method will use this code later

16 A closer look at the Comparator Why did we use an instance of an anoymous class?

17 A closer look at the Comparator Why did we use an instance of an anoymous class? Because there is no other way in Java 7!

18 Another way of writing it Our comparator: Comparator<String> comparator = new Comparator<String>() { } public int compareto(string s1, String s2) { return Integer.compare(s1.length(), s2.length()) ; }

19 Another way of writing it Our comparator: Comparator<String> comparator = new Comparator<String>() { } public int compareto(string s1, String s2) { return Integer.compare(s1.length(), s2.length()) ; } Becomes: Comparator<String> comparator = (String s1, String s2) -> Integer.compare(s1.length(), s2.length()) ;

20 Back to the Comparator interface The Comparator interface public interface Comparator<T> { } public int compare(t t1, T t2) ;

21 Back to the Comparator interface The Comparator interface becomes a functional interface in Java 8 public interface Comparator<T> { } public int compare(t t1, T t2) ;

22 Back to the Comparator interface The Comparator interface becomes a functional interface in Java 8 because it has a single abstract method public interface Comparator<T> { } public int compare(t t1, T t2) ;

23 Back to the Comparator interface A functional interface can be annotated But it is public interface Comparator<T> { } public int compare(t t1, T t2) ;

24

25 So Writing a lambda is a matter of finding what interface to implement The type of a lambda is always known at compile time The method to write a lambda is always the same: - copy / paste the block of parameters - little ASCII art arrow - implement the method

26 A weird thing We wrote this code: List<String> strings =...; strings.foreach( System.out::println // method reference (bound instance) ) ; The foreach() method is defined on the Iterable interface

27 A weird thing We wrote this code: List<String> strings =...; strings.foreach( System.out::println // method reference (bound instance) ) ; The foreach() method is defined on the Iterable interface Do we really want to refactor all the Collection API?

28 Default methods Breaking the backward compatibility is not possible in Java The way interfaces work has been modified: public interface Iterable<E> { // usual methods } default void foreach(consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } }

29 Default methods We can now add methods in interfaces with their implementation Those are «normal» methods It is a new concept of interface, not a new concept of method

30 Default & static methods We can now add methods in interfaces with their implementation Those are «normal» methods It is a new concept of interface, not a new concept of method And static methods are allowed too!

31 Back to the functional interface A functional interface is an interface with only one abstract method So default & static methods do not count

32

33 So Interfaces in Java 8: - Functional interfaces to write lambda expressions - Default methods, can be used to compose them - Static methods, can be used as factory We have better readability, better robustness and better performances! (Youtube: Lambda a peek under the hood by B. Goetz)

34 Package java.util.function 4 categories of functional interfaces: Consumer Supplier Function Predicate

35 Package java.util.function 4 categories of functional interfaces: Consumer t -> {}; Supplier () -> t; Function t -> u; Predicate t -> true;

36 Package java.util.function 4 categories of functional interfaces: Consumer t -> {}; s -> System.out.println(s); Supplier () -> t; () -> new Balloon(); Function t -> u; person -> person.getage(); Predicate t -> true; age -> age > 20;

37 Package java.util.function 4 categories of functional interfaces: Runnable () -> {}; Consumer t -> {}; s -> System.out.println(s); Supplier () -> t; () -> new Balloon(); Function t -> u; person -> person.getage(); Predicate t -> true; age -> age > 20;

38 Package java.util.function 4 categories of functional interfaces: Runnable () -> {}; () -> logger.log(message); Consumer t -> {}; s -> System.out.println(s); Supplier () -> t; () -> new Ballon(); Function t -> u; person -> person.getage(); Predicate t -> true; age -> age > 20;

39 Back to the Comparator Let us write a comparator of people - Using an anonymous class - Then a lambda

40

41 Method reference There are 4 types of method references Nom Static Bound instance Unbound instance Constructor Syntaxe RefType::staticMethod expr::instmethod RefType::instMethod ClassName::new

42 Method reference There are 4 types of method references Lambda d -> Math.sin(d) Method Reference Math::sin s -> System.out.println(s) System.out::println (s, t) -> s.compareto(t) name -> new Person(name) String::compareTo Person::new

43 What about patterns? Let us talk about the GoF

44 What about patterns? Let us talk about the GoF The factory pattern

45

46 What about patterns? Let us talk about the GoF The factory pattern The registry & builder patterns

47

48 Conclusion Lambdas are not just a nice way of writing instances of anonymous classes Functional interfaces + default methods + factory methods provide new ways of implementing well-known patterns for our applications & APIs

49 Thank you!

50