Intro to Lambda Expressions

Lambda Expressions in Java

A lambda expression is an expression that represents an anonymous method, or function. It gets its name from the mathematical system of Lambda Calculus, which is the basis of functional programming languages. In Java, a lambda expression represents a method without a name, and it acts as a shortcut way to write methods that can be treated as data. What does this mean?

A lambda can be passed into or out of a method as an argument or return
A lambda expressions can be assigned to a variable for future use

In Java, the primary usage of lambdas will be in conjunction with functional interfaces.

Remember that this is an interface with exactly one abstract method to define.
In many occasions, a lambda expression is a simpler way to implement the strategy pattern -- i.e. passing a method into another method
We will be able to replace many uses of "anonymous inner classes" with simpler lambda expressions, for example

Lambda syntax

In Java, the core syntax of a lambda expression is a parameter list, an arrow operator, then a body, like this:

   (parameters) -> { statements }

However, there are a number of variations and shortcuts for many cases.

A simple example

Consider this simple function:

  int multiplyByTen(int x)
  {
     return x * 10;
  }

The following is an equivalent lambda expression:

  (int x) -> { return x * 10; }

Note that the compiler infers things from the context, including the return type (int) in this case, because the incoming parameter is an integer.

Syntax variations

A lambda's paramter type can often be omitted, if the compiler can infer the correct type from the context of the lambda's usage. (If it cannot, it will generate an appropriate compiler error message). The prior example becomes:
```
  (x) -> { return x * 10; }
```
If the lambda's body (function body) contains only one expression, the expression itself can be used as a replacement for the entire function body syntax:
```
  (x) -> x * 10
```
When there is only one parameter, the parentheses may be omitted:
```
  x -> x * 10
```
When there are no paramters, use empty parentheses, as with normal functions:
```
  () -> System.out.print("No params!")
```

A few more examples

Function	equivalent lambda
void PrintHello() { System.out.println("Hello, World"); }	() -> System.out.println("Hello, World")
double average(double x, double y, double z) { return (x + y + z) / 3.0; }	(double x, double y, double z) -> (x + y + z) / 3.0 (or, if used in appropriate context): (x, y, z) -> (x + y + z) / 3.0
void updateIfOdd(int x) { if (x % 2 != 0) y = 10; System.out.print("y is now " + y); }	x -> { if (x % 2 != 0) y = 10; System.out.print("y is now " + y); }

Function

equivalent lambda

  void PrintHello()
  {
     System.out.println("Hello, World");
  }

  () -> System.out.println("Hello, World")

  double average(double x, double y, double z)
  {
     return (x + y + z) / 3.0;
  }

  (double x, double y, double z) -> (x + y + z) / 3.0

(or, if used in appropriate context):

  (x, y, z) -> (x + y + z) / 3.0

  void updateIfOdd(int x)
  {
     if (x % 2 != 0)
         y = 10;

     System.out.print("y is now " + y);         
  }

  x -> {  if (x % 2 != 0)
             y = 10;
          System.out.print("y is now " + y);         
       }

Using Lambda Expressions

The most common use of lambdas will be with functional interfaces. Recall our sorting examples, using the Comparator interface to build custom sorting rules, for use with the Arrays.sort() method. These were two previously-seen examples:

Sorting2.java
- In this one, we created three custom classes (with names) that implemented the Comparator interface, then passed objects of those types as the second parameter in Arrays.sort()
SortingAnon.java
- This example did the same, but used anonymous inner classes for the implementations of Comparator, rather than named classes

Recall also that when creating a class that implements Comparator, there was exactly one abstract method that had to be implemented - compare(). This means that Comparator is a functional interface.

Since a lambda expression represents exactly one method (anonymous, without name), it is an ideal shortcut expression that can be used when creating the one method for such an interface parameter.

This version of the sorting program is similar to the "anonymous inner class" version, but uses lambda expressions instead, for simpler parameter syntax in the Arrays.sort() method calls.

SortingLambdas.java

For example, lengthier anonymous inner class notation like this:

  Arrays.sort(nameArray, new Comparator()
  { 
    public int compare(String s1, String s2)
    {
       return (s1.length() - s2.length());
    }
  });

has been simplified with a lambda expression to this:

  Arrays.sort(nameArray, (s1, s2) -> s1.length() - s2.length() );

In library methods that take a functional interface type as a parameter, a lambda expression will typically be a syntactically simpler way to pass in an object that implements the given interface and defines the single method required. In these cases, we don't even need to worry about the method's name, becuase there is only ONE required method to override in a functional interface!

Try rewriting some previously-seen examples that used anonymous inner classes (from our GUI/event-handling examples) with lambda expressions.