Lambda Expressions

Java ≤ 7: Interface for Callbacks

Compute the average balance:

public static double average(BankAccount[] objects)
{
   double sum = 0;
   for (BankAccount obj : objects)
   {
      sum = sum + obj.getBalance();
   }
   if (objects.length > 0) { return sum / objects.length; }
   else { return 0; }
}

What if we want average area of Country objects?
Java ≤ 7: Make an interface

Java ≤ 7: Interface for Callbacks (2)

Make an interface:

public interface Measurer
{
   double getMeasure(Object obj);
}

Use the interface in the utility method:

public static double average(Object[] objects, Measurer meas)
{
   double sum = 0;
   for (Object obj : objects)
   {
      sum = sum + meas.getMeasure(obj);
   }
   if (objects.length > 0) { return sum / objects.length; }
   else { return 0; }
}

Java ≤ 7: Interface for Callbacks (3)

Not done yet...

Make an instance of the interface:

public class BankAccountMeasurer implements Measurer
{
   public double average(Object obj)
   {
      BankAccount account = (BankAccount) obj;
      return account.getBalance();
   }
}

Instantiate that class:

BankAccountMeasurer accountMeas = new BankAccountMeasurer();
double averageBalance = average(accounts, accountMeas);

Your Turn

Complete this program to compute the average length of the words that are entered in the input line. For example, if the input was

Bonjour le monde!

the program should print 5.0 (since (7 + 2 + 6)/3 = 5).

Make a class that implements the Measurable interface. Make an object of that class. Pass it to the average method.

Lambda Expressions

Using a method such as average is too much work
That's why you don't find many such methods in the standard library
Java 8 makes this much easier: Use a lambda expression
Works with interfaces that have a single abstract method
- Such interfaces are called functional interfaces...
- ...because instances are similar to mathematical functions
Lambda expression specifies:
- Parameters
- Code for computing the returned value
Example of a lambda expression: A function that gets the balance of a bank account
```
(Object obj) -> ((BankAccount) obj).getBalance()
```
- Name “lambda expression” comes from a mathematical notation that uses the greek letter lambda (λ) instead of the -> symbol

Lambda Expressions 2

In Java, a lambda expression cannot stand alone.

It must be assigned to a variable whose type is a functional interface:

Measurer accountMeas =
   (Object obj) -> ((BankAccount) obj).getBalance();

Now the following actions occur:
1. A class is defined that implements the functional interface. The single abstract method is defined by the lambda expression.
2. An object of that class is constructed.
3. The variable is assigned a reference to that object.
Can also pass lambda expression to a method:
```
double averageBalance = average(accounts,
   (Object obj) –> ((BankAccount) obj).getBalance());
```
Then the parameter variable is initialized with the object

Your Turn

Complete this program to compute the average length of the words that are entered in the input line. This time, use a lambda expression.

You'll need to cast obj to the appropriate type and apply a method.

Adding Generics

Ugly to use Object with Measurable

Make parameter generic:

public interface Measurer<T>
{
   public double getMeasure(T obj);
}

Then make utility method generic:

public static <T> double average(T[] objects, Measurer<T> meas)
{
   double sum = 0;
   for (T obj : objects) ...
   ...
}

Actually, it should be Measurer<? super T>, but we'll ignore that for now.

Parameter Type Inference

Sometimes, the compiler can infer type of lambda parameters

Then you can omit the type:

obj -> obj.getBalance() // Instead of (Object obj) -> ...

This is the case when using the generic average method:

BankAccount[] accounts = ...;
double averageBalance = average(accounts,
   obj –> obj.getBalance());

Because accounts is a BankAccount[], T must be BankAccount...
...and since the method parameter is T, the type of obj is inferred.
If there is more than one parameter, still need parentheses:
```
(v, w) -> v.length() - w.length()
```

If body of lambda is more than a single expression, use {, }, return:

(v, w) ->
   {
      int first = v.length();
      int second = w.length();
      return first - second;
   }

Your Turn

Put type inference to work by completing this program. Use a lambda expression that doesn't have a parameter type.

Exercises

The Collection<T> interface has a method removeIf that accepts a Predicate<T>, a functional interface for a function T -> boolean. All elements for which the function is true are removed.
Complete this program to remove all elements with length < 20 from a list of words.
Complete this program to keep only the words that start and end with the same letter (ignoring letter case). Use a lambda expression of the form ... -> { ... }. Hint: substring, equalsIgnoreCase.
One use for a Map<String, Integer> is to count how often a word occurs in a text. It is a bit tedious to deal with the special case of inserting the first value.
```
Integer count = frequencies.get(word); // Get the old frequency count
// If there was none, put 1; otherwise, increment the count
if (count == null) { count = 1; }
else { count = count + 1; }
frequencies.put(word, count);
```
Java 8 adds a useful merge method to the Map interface. You specify
- A key
- A value to be used if the key is not yet present.
- A function to compute the updated value if the key is present.
The function receives the old map value and the “not yet present” value, and it returns the new map value.
```
frequencies.merge(word, 1, (oldValue, value) -> oldValue + value);
```
The merge method is also useful if the map values are sets or comma-separated strings.

Complete this program that tracks all lines on which a given word occurs. Remove the if statement and instead use a call to merge.
Do the same in this program. Note that it's not quite so easy. You have two choices. Your function can compute and return the union of two sets. Or you can use merge just to make sure there is a set, and then call index.get(...).add(...).