LAMBDA EXPRESSIONS AND STREAMS API

Transcription

1 Java 8 LAMBDA EXPRESSIONS AND STREAMS API An Introduction

2 Methods As Data 2

3 @FunctionalInterface public interface Runnable { public abstract void run(); public interface ActionListener extends EventListener { public void actionperformed(actionevent e); public interface Comparator<T> { int compare(t o1, T o2); boolean equals(object obj);... Functional Interface Has only one abstract method declared may have other default method declarations may have other static method declarations may have method declarations from Object sometimes known as SAM (Single Abstract Method) interfaces Many Functional Interfaces in API Runnable ActionListener Comparator Can be used as a Target for Lambda Expressions New 3

4 interface Calc { int calculate(int a, int b); public class FunctionalInterfaces { int doescalc (Calc calc) { return calc.calculate(3, public final void testwithanon() { FunctionalInterfaces fi = new FunctionalInterfaces(); int answer = fi.doescalc(new Calc() { public int calculate(int a, int b) { return a + b; ); assertequals(8, answer); 4

5 interface Calc { int calculate(int a, int b); public class FunctionalInterfaces { int doescalc (Calc calc) { return calc.calculate(3, public final void testwithlambda() { FunctionalInterfaces fi = new FunctionalInterfaces(); int answer = fi.doescalc((int x, int y) -> {return x+y;); assertequals(8, answer); 5

6 Syntax Multiple forms (Parameters) -> { statements; or (Parameters) -> expression; Parameter Types may be declared or inferred 6

7 @Test public final void testwithlambda1() { FunctionalInterfaces fi = new FunctionalInterfaces(); int answer = fi.doescalc((int x, int y) -> {return x+y;); assertequals(8, answer); int answer = fi.doescalc((x,y) -> {return x+y;); int answer = fi.doescalc((x,y) -> public final void testwithlambda4() { FunctionalInterfaces fi = new FunctionalInterfaces(); int answer = fi.doescalc((x,y) -> {int a = x*x; int b = y*y; return a+b;); assertequals(34, answer); 7

8 Compile Time Error interface Calc { int calculate(int a, int b); public class FunctionalInterfaces { int doescalc (Calc calc) { return calc.calculate(3, public final void testwithlambda() { FunctionalInterfaces fi = new FunctionalInterfaces(); int answer = fi.doescalc((x,y) -> x.concat(y)); assertequals(8, answer); 8

9 Without Parameters void runthread() { new Thread(() -> System.out.println("with lambdas")).start(); void runthread() { new Thread(new Runnable() public void run() { System.out.println("with anonymous inner class"); ).start(); 9

10 Method References Concrete method of existing class Can reference static or instance methods Both are converted to Lambda Expressions void sortarray() { Integer[] ints = {3,5,7,1; Arrays.sort(ints, Integer::compare); - OR - Arrays.sort(ints, (x,y) -> Integer.compare(x, y)); 10

11 java.util.function Contains Functional Interfaces Used as target types for Lambda Expressions Used extensively by the JDK Basic Shapes Function (takes an argument and produces a result) Consumer (takes an argument and returns void) Predicate (takes and argument and returns boolean) Supplier (takes no argument returns result) arity Modifiers BiConsumer, BiFunction, BiPredicate (take 2 arguments) Primitive Specializations DoubleToIntFunction, LongConsumer, etc. 11

12 BiFunction BiFunction<String, String, String> concat = (s1, s2) -> s1.concat(s2); void mapmerge() { HashMap<String, String> map = new HashMap<>(); map.merge("new_key", "new_value", concat); - OR - map.merge("new_key", "new_value", (s1, s2) -> s1.concat(s2)); - OR - map.merge("new_key", "new_value", String::concat); 12

13 STREAM API Map and Reduce 13

14 STREAM API Streams are sequences of values java.util.stream Stream, IntStream, LongStream, DoubleStream Similar to iterators, but not backed by any particular collection Defines operators which are usually Functional Interfaces Operators manipulate the data as it flows through the stream Intermediate operators are lazy Construct stream pipeline but do not transform any data immediately Terminal operators are eager Causes the entire pipeline to be activated 14

15 STREAM API Intermediate Operators <R> Stream<R> map (Function <T,R> mapper) mapper function will map an element of type T to an element of type R called on a stream of type T, will return a stream of type R Stream<T> filter (Predicate<T> predicate) predicate function will be used to validate each element in called stream returns a new stream of type T with only the filtered elements <R> Stream<R> flatmap (Function<T, Stream<R>> mapper) maps each element of type T to a stream of elements of type R mapped streams are merged and output as a single stream of type R Stream<T> sorted() -or- (Comparator<T> comparator) each element is sorted by either their own compareto, or the given comparator stateful operator, needs to wait for all data from any upstream operators 15

16 STREAM API Terminal Operators void foreach (Consumer<T> consumer) each element in the stream will be processed by the consumer function <R> R collect (Collector<T,R> collector) collects all elements of the stream into a resultant collection Collectors class has many options for results - Collectors.toList - Collectors.toCollection(TreeSet::new) - Collectors.summingInt(p -> p.amount) Iterator<T> () returns an Iterator that can be used to further manipulate the stream outputs 16

17 STREAM API Short-Circuit Operators Intermediate Stream<T> limit (long) returns specified number of elements from stream as a new stream Terminal boolean allmatch (Predicate<T> predicate) will short-circuit if any element fails predicate test boolean anymatch (Predicate<T> predicate) will short-circuit as soon as a match is found boolean nonematch(predicate<t> predicate will short-circuit as soon as a match is found 17

18 STREAM API class Restaurant { int rating() { return rating; List<Restaurant> getgoodrestaurants(list<restaurant> list) { ArrayList<Restaurant> good = new ArrayList<Restaurant>(); for (Restaurant restaurant : list) { if (restaurant.rating() > 3) { good.add(restaurant); return good; - with Stream API - List<Restaurant> getgoodrestaurants2(list<restaurant> list) { return list.stream().filter(r -> r.rating() > 3).collect(Collectors.toList()); 18

19 STREAM API Concurrency Streams are executed in sequence by default Internal iteration allows for other execution strategies Use of a ParallelStream allows execution over multiple cores The parallelstream() method will return a stream ready for concurrency All future operators will be handled in parallel The stream will be split into multiple substreams Substreams will be operated on in parallel and results will be combined. Watch out for side effects 19

20 STREAM API List<Restaurant> getgoodrestaurants2(list<restaurant> list) { return list.stream().filter(r -> r.rating() > 3).collect(Collectors.toList()); - becomes - List<Restaurant> getgoodrestaurants2(list<restaurant> list) { return list.parallelstream().filter(r -> r.rating() > 3).collect(Collectors.toList()); 20

21 THANK YOU any questions?