Core Java Advanced LiveLessons

Java 8 Interfaces and Lambda Expressions

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

.jpg

Recall the concept of interfaces

The Interface Concept

Interface=set of requirements for classes.
Class can choose to conform to one or more interfaces.
Interface is not a class.
Service provider promises caller: “If your class conforms to a particular interface, then I'll perform the service.”
Example: Arrays.sort sorts an array if the element class conforms to the Comparable interface.

Interface definition:

public interface Comparable<T> {
    int compareTo(T other); // automatically public
}

Conforming class must provide compareTo method.

Implementing an Interface

A class can choose to implement one or more interfaces:

public class Employee implements Comparable<Employee> {
    public int compareTo(Employee other) {
        return Double.compare(salary, other.salary);
    }
    ...
}

Now we can sort an array of Employee objects:

Employee[] staff = ...;
Arrays.sort(staff);

Making Use of an Interface

A sorting algorithm keeps comparing elements and rearranges them if they are out of order:
```
if (a[i].compareTo(a[j]) > 0) {
    // rearrange a[i] and a[j]
    ...
}
```
How does the compiler know that the call a[i].compareTo(a[j]) is valid?

If a[i] is an instance of Comparable, then a[i] has a compareTo method:

public static <T extends Comparable<? super T>> void sort(T[] a)

lesson01/interfaces

Add logging to show invocation

Understand Java 8 features of interfaces

Static Methods in Interfaces

Allowed since Java 8.
Originally disallowed since it wasn't in the spirit of interfaces as abstract specifications.
You can find many pairs of interface/companion class in the Java API: Collection/Collections, Path/Paths
The Paths class has a factory method get to make a Path object.

In Java 8, this would be better solved with a static method in the Path interface:

public interface Path {
    public static Path get(String first, String... more) {
        return FileSystems.getDefault().getPath(first, more);
    }
    ...
}

Default Methods in Interfaces

Can supply a default implementation for any interface method:

public interface Comparable<T> {
    default int compareTo(T other) { return 0; }
    // By default, all elements are the same
}

More compelling example—event handler:

public interface MouseListener {
    default void mouseClicked(MouseEvent event) {}
    default void mousePressed(MouseEvent event) {}
    ...
}

A default method can call an abstract method:

public interface Collection {
    int size(); // An abstract method
    default boolean isEmpty() { return size() == 0; }
    ...
}

Interface Evolution

Consider the Collection interface that has been in the JDK for many years.
Suppose someone provided a class Bag implementing Collection.
Later, another method is added to Collection. (This actually happened with the stream method in JDK 8.)
If it's not a default method, then Bag no longer compiles—the change is not source compatible.
The same change is binary compatible—the Bag class still works, as long as nobody calls the new method. (Otherwise, an AbstractMethodError occurs.)
Making a new interface method a default method solves both problems.

Resolving Default Method Conflicts

What happens when the exact same method is defined as a default method in one interface and again as a method of a superclass or another interface?
Two simple rules:
- Interfaces clash. If an interface provides a default method and another interface provides the same one (default or not), you must resolve the conflict:
```
interface Person { default String getName() { ... }}
interface Named { default String getName() { ... }}
class Employee implements Person, Named {
    public String getName() { return Person.super.getName(); }
    ...
}
```
- Superclasses win. Concrete superclass methods mask default methods:
```
class Employee { public String getName() { ... } ... }
class Manager extends Employee implements Named { ... }
```
- Only the superclass method matters.
- The default method Named.getName is ignored.
- Ensures compatibility with Java 7: If you add a default method to an interface, it has no impact on existing code.

Recall how interfaces are used for callbacks

Callbacks

Callback: Action that should happen at some point in the future.
You saw how Arrays.sort sorts an array of Comparable objects.
What if you want to sort the objects in a different way?
What if the objects belong to a class that doesn't implement Comparable?

A second version of Arrays.sort accepts a comparator callback:

public interface Comparator<T> {
    int compare(T first, T second);
}

This comparator compares strings by length:

class LengthComparator implements Comparator<String> {
    public int compare(String first, String second) {
        return first.length() - second.length();
    }
}

Pass an instance to Arrays.sort:

String[] friends = { "Peter", "Paul", "Mary" };
Arrays.sort(friends, new LengthComparator());

The callback is invoked when the sorting algorithm compares elements.

lesson01/interfaces

Change to comparator:

class NameComparator implements Comparator<Employee> {
    public int compare(Employee first, Employee second) {
        return first.getName().compareTo(second.getName());
    }
}

Add logging to show invocation

Java 9 News Flash - Private Interface Methods

.png

Interfaces can have concrete private and private static methods.
Any interface method is abstract, default, static, private, or private static
Private methods can only be called from default and static methods of the same interface.
Potentially useful for factoring out common code.

Understand how lambda expressions work

Why Lambdas?

Lambda expression = Block of code that you can pass around so it can be executed later.
Reduces tedious boilerplate for callbacks.
When sorting strings by length, the compare method had to be called repeatedly to compute:
```
first.length() - second.length()
```

Lambda expression:

(String first, String second) -> first.length() - second.length()

Much simpler than:

class LengthComparator implements Comparator<String> {
    public int compare(String first, String second) {
        return first.length() - second.length();
    }
}

The Syntax of Lambda Expressions

Simplest form: (parameters) -> expression

If the code doesn't fit in a single expression, use { } and a return statement:

(String first, String second) -> {
    if (first.length() < second.length()) return -1;
    else if (first.length() > second.length()) return 1;
    else return 0;
}

If there are no parameters, you still supply parentheses:
```
() -> System.out.println(Instant.now()); 
```

If parameter types can be inferred, omit them:

Comparator<String> comp = (first, second) -> first.length() - second.length();

If there is exactly one parameter with inferred type, omit parentheses:
```
ActionListener listener = event -> System.out.println(event);
```

Functional Interfaces

Functional interface = Interface with a single abstract method.
- Examples: Runnable, ActionListener, Comparator

Lambda expression can be used whenever a functional interface value is expected:

Arrays.sort(words,
    (first, second) -> first.length() - second.length());

Timer t = new Timer(1000, event -> {
        System.out.println("At the tone, the time is " + Instant.now());
    });

Conversion to a functional interface is the only thing that you can do with a lambda expression.

lesson01/interfaces

Pass (e1, e2) -> e1.getName().compareTo(e2.getName())

Generic Functional Interfaces

The java.util.function package defines generic functional interfaces:

public interface Predicate<T> {
    boolean test(T t);
    ...
}

public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

ArrayList has a removeIf method that takes a predicate:
```
list.removeIf(e -> e == null);
```

Method References

Consider a lambda expression that calls a single method:

Timer t = new Timer(1000, event -> System.out.println(event));

You can use a method reference instead:

Timer t = new Timer(1000, System.out::println);

Another example:

Arrays.sort(words, String::compareToIgnoreCase)

Three cases:
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod

Constructor References

Person::new is a reference to a Person constructor.
- Same as s -> new Person(s)
- The compiler uses overloading resolution to pick the correct constructor.

Example—turn list of names into list of Person objects:

ArrayList<String> names = . . .;
Stream<Person> stream = names.stream().map(Person::new);

The map method turns a stream of strings into a stream of Person objects.
Constructor references also work for arrays:
- int[]::new is the same as the lambda expression n -> new int[n]
- Useful to overcome limitation of Java generics: Illegal to call new T[n]
- Turn stream to array of the correct type:
```
Person[] people = stream.toArray(Person[]::new);
```

Variable Scope

A lambda expression can access variables from the enclosing scope:

public static void repeatMessage(String text, int delay) {
    ActionListener listener = event -> {
        System.out.println(text);
    };
    new Timer(delay, listener).start();
}

Consider a call:

repeatMessage("Hello", 1000); // Prints Hello every 1,000 milliseconds

The text variable is not defined in the lambda expression.
It is gone when repeatMessage returns!
A lambda expression is a closure, containing:
1. A block of code
2. Parameters
3. Values for the free variables

Effectively Final Variables

A lambda variable can only capture a variable whose value is effectively final:

public static void countDown(int start, int delay) {
    ActionListener listener = event -> {
        start--; // Error: Can't mutate captured variable
        System.out.println(start);
    };
    new Timer(delay, listener).start();
}

Also illegal if the variable changes outside the lambda expression:

public static void repeat(String text, int count) {
    for (int i = 1; i <= count; i++) {
        ActionListener listener = event ->
            System.out.println(i + ": " + text); // Error: Cannot refer to changing i
        new Timer(1000, listener).start();
    }
}

Processing Lambda Expressions

Repeat an action n times:

repeat(10, () -> System.out.println("Hello, World!"));

Pick a functional interface for the second parameter:

public static void repeat(int n, Runnable action) {
    for (int i = 0; i < n; i++) action.run();
}

To pass the count to the action, pick a functional interface from the java.util.function package:

public static void repeat(int n, IntConsumer action) {
    for (int i = 0; i < n; i++) action.accept(i);
}

Called like this:

repeat(10, i -> System.out.println("Countdown: " + (9 - i)));

More about Comparators

Comparator interface has useful methods for creating and composing comparators.
The static method comparing makes a comparator from a key extractor function:
```
Arrays.sort(people, Comparator.comparing(Employee::getName));
```
If the key is a primitive type, use comparingInt or comparingDouble to avoid boxing:
```
Arrays.sort(words, Comparator.comparingInt(String::length));
```

The default method thenComparing chains comparators:

Arrays.sort(people,
    Comparator.comparingDouble(Employee::getSalary)
        .thenComparing(Employee::getName));

lesson01/interfaces

Comparator.comparingDouble(Employee::getSalary)
    .thenComparing(Employee::getName));