updated ch02 on Lambdas

Author: shekhargulati

02-lambdas.md

@@ -1,11 +1,14 @@
-## Lambdas
+Lambdas
+-----
 
-From today, I am kicking off **7 Days with Java 8** blog series with first blog on Lambdas. One of the most important features in Java 8 is the introduction of Lambda expressions. They make your code concise and allows you to pass behavior around. For some time now, Java is criticized for being verbose and for lacking functional programming capabilities. With functional programming becoming more popular and relevant, Java is forced to embrace the functional style of programming. Else, Java would become irrelevant.
+One of the most important features in Java 8 is the introduction of Lambda expressions. They make your code concise and allows you to pass behavior around. For some time now, Java is criticized for being verbose and for lacking functional programming capabilities. With functional programming becoming more popular and relevant, Java is forced to embrace the functional style of programming. Else, Java would become irrelevant.
 
 Java 8 is a big step forward in making the world's most popular language adopt the functional style of programming. To support functional programming style, a language needs to support functions as first class citizen. Prior to Java 8, writing a clean functional style code was not possible without the use of an anonymous inner class boilerplate. With the introduction of Lambda expressions, functions have become first class citizen and they can be passed around just like any other variable.
 
 Lambda expressions allow you to define an anonymous function that is not bound to an identifier. You can use them like any other construct in your programming language like variable declaration. Lambda expressions are required if a programming language needs to support higher order functions. Higher order functions are functions that either accept other functions as arguments or returns a function as a result.
 
+> Code for this section is inside [ch02 package](https://github.com/shekhargulati/java8-the-missing-tutorial/tree/master/code/src/main/java/com/shekhargulati/java8_tutorial/ch02).
+
 Now, with the introduction of Lambda expressions in Java 8, Java supports higher order functions. Let us look at the  canonical example of Lambda expression -- a sort function in Java's `Collections` class. The `sort` function has two variants -- one that takes a `List` and another that takes a `List` and a `Comparator`. The second `sort` function is an example of a Higher order function that accepts a lambda expression as shown below in the code snippet.
 
 ```java
@@ -27,7 +30,7 @@ The expression `(first, second) -> first.length() - second.length()` shown above
 
 Before we dig deeper into Java 8 Lambdas support, let's look into their history to understand why they exist.
 
-### History of Lambdas
+## History of Lambdas
 
 Lambda expressions have their roots in the Lambda Calculus. [Lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus) originated from the work of [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church) on formalizing the concept of expressing computation with functions. Lambda calculus is turing complete formal mathematical way to express computations. Turing complete means you can express any mathematical computation via lambdas.
 
@@ -47,7 +50,7 @@ The main concept in Lambda calculus is expressions. An expression can be express
 
 Now, you understand Lambda calculus and its impact on functional programming languages. Let's learn how they are implemented in Java 8.
 
-### Passing behavior before Java 8
+## Passing behavior before Java 8
 
 Before Java 8, the only way to pass behavior was to use anonymous classes. Suppose you want to send an email in another thread after user registration. Before Java 8, you would write code like one shown below.
 
@@ -59,6 +62,7 @@ sendEmail(new Runnable() {
             }
         });
 ```
+
 The sendEmail method has following method signature.
 
 ```java
@@ -75,9 +79,9 @@ Iterable<Task> lambdaTasks = Iterables.filter(tasks, new Predicate<Task>() {
             }
 });
 ```
-With Java 8 Stream API, you can write the above mentioned code without the use of a third party library like Guava. We will cover streams on Day 2. So, stay tuned!!
+With Java 8 Stream API, you can write the above mentioned code without the use of a third party library like Guava. We will cover streams in [chapter 3](./03-streams.md). So, stay tuned!!
 
-### Java 8 Lambda expressions
+## Java 8 Lambda expressions
 
 In Java 8, we would write the code using a lambda expression as show below. We have mentioned the same example in the code snippet above.
 
@@ -87,11 +91,12 @@ sendEmail(() -> System.out.println("Sending email..."));
 
 The code shown above is concise and does not pollute the programmer's intent to pass behavior. `()` is used to represent no function parameters i.e. `Runnable` interface `run` method does not have any parameters. `->` is the lambda operator that separates the parameters from the function body which prints `Sending email...` to the standard output.
 
-Let's look at the Collections.sort example again so that we can understand how lambda expressions work with the parameters. To sort a List of names by their length, we used Collections.sort function as shown below.
+Let's look at the Collections.sort example again so that we can understand how lambda expressions work with the parameters. To sort a list of names by their length, we passed a `Comparator` to the sort function. The `Comparator` is shown below.
 
 ```java
 Comparator<String> comparator = (first, second) -> first.length() - second.length();
 ```
+
 The lambda expression that we wrote was corresponding to compare method in the Comparator interface. The signature of `compare` function is shown below.
 
 ```java
@@ -107,28 +112,30 @@ In the lambda expression, we didn't have to explicitly provide the type -- Strin
 Comparator comparator = (first, second) -> first.length() - second.length(); // compilation error - Cannot resolve method 'length()'
 ```
 
-### How does Lambda expressions work in Java 8?
+## How does Lambda expressions work in Java 8?
 
-You may have noticed that the type of a lambda expression is some interface like Comparator in the above example. You can't use any interface with lambda expression. Only those interfaces which have only one non-object abstract method can be used with lambda expressions. These kinds of interfaces are called **Functional interfaces** and they are annotated with `@FunctionalInterface` annotation. Runnable interface is an example of functional interface as shown below. `@FunctionalInterface` annotation is not mandatory but, it can help tools know that an interface is a functional interface and perform meaningful actions. For example, if you try to compile an interface that annotates itself with `@FunctionalInterface` annotation and has multiple abstract methods then compilation will fail with an error ***Multiple non-overriding abstract methods found***. Similarly, if you add `@FunctionInterface` annotation to an interface without any method i.e. a marker interface then you will get error message ***No target method found***.
+You may have noticed that the type of a lambda expression is some interface like Comparator in the above example. You can't use any interface with lambda expression. ***Only those interfaces which have only one non-object abstract method can be used with lambda expressions***. These kinds of interfaces are called **Functional interfaces** and they can be annotated with `@FunctionalInterface` annotation. Runnable interface is an example of functional interface as shown below.
 
 ```java
 @FunctionalInterface
 public interface Runnable {
     public abstract void run();
 }
-
 ```
 
-Let's answer one of the most important questions that might be coming to your mind. Are Java 8 lambda expressions just the syntactic sugar over anonymous inner classes or how does functional interface gets translated to bytecode?
+`@FunctionalInterface` annotation is not mandatory but, it can help tools know that an interface is a functional interface and perform meaningful actions. For example, if you try to compile an interface that annotates itself with `@FunctionalInterface` annotation and has multiple abstract methods then compilation will fail with an error ***Multiple non-overriding abstract methods found***. Similarly, if you add `@FunctionInterface` annotation to an interface without any method i.e. a marker interface then you will get error message ***No target method found***.
+
+Let's answer one of the most important questions that might be coming to your mind. ***Are Java 8 lambda expressions just the syntactic sugar over anonymous inner classes or how does functional interface gets translated to bytecode?***
 
 The short answer is **NO**. Java 8 does not use anonymous inner classes mainly for two reasons:
 
 1. **Performance impact**: If lambda expressions were implemented using anonymous classes then each lambda expression would result in a class file on disk. When these classes are loaded by JVM at startup, then startup time of JVM will increase as all the classes needs to be first loaded and verified before they can be used.
+
 2. **Possibility to change in future**: If Java 8 designers would have used anonymous classes from the start then it would have limited the scope of future lambda implementation changes.
 
-#### Using invokedynamic
+### Using invokedynamic
 
-Java 8 designers decided to use invokedynamic instruction added in Java 7 to defer the translation strategy at runtime. When`javac` compiles the code, it captures the lambda expression and generates an invokedynamic call site (called lambda factory). The invokedynamic call site when invoked returns an instance of the Functional Interface to which the lambda is being converted. For example, if we look at the byte code of our Collections.sort example, it will look like as shown below.
+Java 8 designers decided to use `invokedynamic` instruction added in Java 7 to defer the translation strategy at runtime. When`javac` compiles the code, it captures the lambda expression and generates an `invokedynamic` call site (called lambda factory). The `invokedynamic` call site when invoked returns an instance of the functional interface to which the lambda is being converted. For example, if we look at the byte code of our Collections.sort example, it will look like as shown below.
 
 ```
 public static void main(java.lang.String[]);
@@ -163,49 +170,59 @@ public static void main(java.lang.String[]);
 
 The interesting part of the byte code shown above is the line 23 `23: invokedynamic #7,  0              // InvokeDynamic #0:compare:()Ljava/util/Comparator;` where a call to `invokedynamic` is made.
 
-The second step is to convert the body of the lambda expression into a method that will be invoked through the invokedynamic instruction. This is the step where JVM implementers have the liberty to choose their own strategy.
+The second step is to convert the body of the lambda expression into a method that will be invoked through the `invokedynamic` instruction. This is the step where JVM implementers have the liberty to choose their own strategy.
 
 I have only glossed over this topic. You can read about internals at http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html.
 
-### Anonymous classes vs lambdas
+## Anonymous classes vs lambdas
+
+Let's compare anonymous classes with lambdas to understand the differences between them.
 
 1. In anonymous classes, `this` refers to the anonymous class itself whereas in lambda expression `this` refers to the class enclosing the lambda expression.
 
 2. You can shadow variables in the enclosing class inside the anonymous class. This gives compile time error when done inside lambda expression.
 
 3. Type of the lambda expression is determined from the context where as type of the anonymous class is specified explicitly as you create the instance of anonymous class.
 
-### Do I need to write my own functional interfaces?
+## Do I need to write my own functional interfaces?
 
 By default, Java 8 comes with many functional interfaces which you can use in your code. They exist inside `java.util.function` package. Let's have a look at few of them.
 
-#### java.util.function.Predicate<T>
+### java.util.function.Predicate<T>
 
 This functional interface is used to define check for some condition i.e. a predicate. Predicate interface has one method called `test` which takes a value of type `T` and return boolean. For example, from a list of `names` if we want to filter out all the names which starts with **s** then we will use a predicate as shown below.
 
 ```java
 Predicate<String> namesStartingWithS = name -> name.startsWith("s");
 ```
 
-#### java.util.function.Consumer<T>
+### java.util.function.Consumer<T>
 
 This functional interface is used for performing actions which does not produce any output. Predicate interface has one method called `accept` which takes a value of type `T` and return nothing i.e. it is void. For example, sending an email with given message.
 
 ```java
 Consumer<String> messageConsumer = message -> System.out.println(message);
 ```
 
-#### java.util.function.Function<T,R>
+### java.util.function.Function<T,R>
 
 This functional interface takes one value and produces a result. For example, if we want to uppercase all the names in our `names` list, we can write a Function as shown below.
 
 ```java
 Function<String, String> toUpperCase = name -> name.toUpperCase();
 ```
 
-We will cover more functional interfaces as we move along in the series.
+### java.util.function.Supplier<T>
+
+This functional interface does not take any input but produces a value. This could be used to generate unique identifiers as shown below.
+
+```java
+Supplier<String> uuidGenerator= () -> UUID.randomUUID().toString();
+```
+
+We will cover more functional interfaces throughout this tutorial.
 
-### Method references
+## Method references
 
 There would be times when you will be creating lambda expressions that only calls a specific method like `Function<String, Integer> strToLength = str -> str.length();`. The lambda only calls `length()` method on the `String` object. This could be simplified using method references like `Function<String, Integer> strToLength = String::length;`. They can be seen as shorthand notation for lambda expression that only calls a single method. In the expression `String::length`, `String` is the target reference, `::` is the delimiter, and `length` is the function that will be called on the target reference. You can use method references on both the static and instance methods.
 
@@ -217,7 +234,7 @@ Suppose we have to find a maximum number from a list of numbers then we can writ
 
 This is used for method reference to an instance method for example `String::toUpperCase` calls `toUpperCase` method on a `String` reference. You can also use method reference with parameters for example `BiFunction<String, String, String> concatFn = String::concat`. The `concatFn` can be called as `concatFn.apply("shekhar", "gulati")`. The `String` `concat` method is called on a String object and  passed a parameter like `"shekhar".concat("gulati")`.
 
-### Exercise >> Lambdify me
+## Exercise >> Lambdify me
 
 Let's look at the code shown below and apply what we have learnt so far.
 

code/src/main/java/com/shekhargulati/java8_tutorial/ch02/Example1_Lambda.java

@@ -0,0 +1,45 @@
+package com.shekhargulati.java8_tutorial.ch02;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class Example1_Lambda {
+
+    public static void main(String[] args) {
+        List<String> names = Arrays.asList("shekhar", "rahul", "sameer");
+        // sort alphabetically
+        Collections.sort(names);
+        System.out.println("names sorted alphabetically  >>");
+        System.out.println(names);
+        System.out.println();
+
+        // using anonymous classes
+        Collections.sort(names, new Comparator<String>() {
+            @Override
+            public int compare(String o1, String o2) {
+                return o1.length() - o2.length();
+            }
+        });
+        System.out.println("names sorted by length  >>");
+        System.out.println(names);
+        System.out.println();
+
+        /**
+         * Using lambda
+         * Things to show >>
+         * 1. return statement
+         * 2. Without return statement
+         * 3. Multiple lines
+         * 4. Type inference
+         */
+
+        Collections.sort(names, (String first, String second) -> second.length() - first.length());
+        System.out.println("names sorted by length(reversed)  >>");
+        System.out.println(names);
+        System.out.println();
+    }
+
+
+}

code/src/main/java/com/shekhargulati/java8_tutorial/ch02/Example2_Lambda.java

@@ -0,0 +1,17 @@
+package com.shekhargulati.java8_tutorial.ch02;
+
+/**
+ *
+ * Example of compiler unable to detect lambda expression types
+ */
+public class Example2_Lambda {
+
+    public static void main(String[] args) {
+
+//        Comparator comparator = (first, second) -> first.length() - second.length();
+
+
+    }
+}
+
+

code/src/main/java/com/shekhargulati/java8_tutorial/ch02/Example3_Functionalnterfaces.java

@@ -0,0 +1,22 @@
+package com.shekhargulati.java8_tutorial.ch02;
+
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public class Example3_Functionalnterfaces {
+
+    public static void main(String[] args) {
+
+        Predicate<String> nameStartWithS = name -> name.startsWith("s");
+
+        Consumer<String> sendEmail = message -> System.out.println("Sending email >> " + message);
+
+        Function<String, Integer> stringToLength = name -> name.length();
+
+        Supplier<String> uuidSupplier = () -> UUID.randomUUID().toString();
+
+    }
+}

code/src/main/java/com/shekhargulati/java8_tutorial/ch02/Example4_MethodReferences.java

@@ -0,0 +1,36 @@
+package com.shekhargulati.java8_tutorial.ch02;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+import static java.util.Comparator.comparingInt;
+
+public class Example4_MethodReferences {
+
+    public static void main(String[] args) {
+        List<String> names = Arrays.asList("shekhar", "rahul", "sameer");
+
+        List<Integer> namesLength = transform(names, String::length);
+        System.out.println(namesLength);
+
+        List<String> upperCaseNames = transform(names, String::toUpperCase);
+        System.out.println(upperCaseNames);
+
+        List<Integer> numbers = transform(Arrays.asList("1", "2", "3"), Integer::parseInt);
+        System.out.println(numbers);
+
+        Collections.sort(names, comparingInt(String::length).reversed());
+        System.out.println(names);
+    }
+
+    private static <T, R> List<R> transform(List<T> list, Function<T, R> fx) {
+        List<R> result = new ArrayList<>();
+        for (T element : list) {
+            result.add(fx.apply(element));
+        }
+        return result;
+    }
+}

code/src/main/java/com/shekhargulati/java8_tutorial/ch02/InvalidFunctionInterface.java

@@ -0,0 +1,17 @@
+package com.shekhargulati.java8_tutorial.ch02;
+
+/**
+ * Example of @FunctionalInterface
+ */
+
+@FunctionalInterface
+public interface InvalidFunctionInterface {
+
+    public boolean test();
+
+//    public boolean test1();
+
+
+}
+
+