Lambdas and Functional Interfaces

What you want is to hand over the line itself.

Collections.sort(students, (a, b) -> Integer.compare(a.marks, b.marks));

This is a lambda. Read the arrow as “maps to”: these inputs map to this answer.

The shape is always the same.

(parameters)  ->  what to do with them

Compare it against what it replaced, side by side:

Every one of those “no” answers is something Java can already work out, and the reason it can is the shape of the interface.

Comparator has one abstract method. So when a Comparator is expected and you write a lambda, there is nothing to decide. The method must be compare. The parameters must be two Student values, because the variable is a Comparator<Student>. The return must be an int.

An interface with exactly one abstract method is called a functional interface. You met the name in Section 8.5. This is what it was for.

Default methods do not break it. A default method already has a body, so it is not waiting to be written. Comparator has many of them, reversed and thenComparing among others, and it is still a functional interface because only compare is abstract.

The four shapes a lambda comes in:

// no parameters
() -> System.out.println("done")

// one parameter, brackets optional
s -> s.length()
(s) -> s.length()

// several parameters
(a, b) -> a + b

// a block, when one expression is not enough. return comes back
(a, b) -> {
    int diff = a.marks - b.marks;
    return diff != 0 ? diff : a.name.compareTo(b.name);
}

Types are optional too, because Java can see them from the interface:

(Student a, Student b) -> ...     // allowed
(a, b) -> ...                     // usual

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. What makes an interface a functional interface, and why does the rule have to be that strict?

   Show the answer

   It has exactly one abstract method. Default methods do not count, however many there are, because a default method already has a body.

   The rule has to be that strict because of what a lambda leaves out. When you write (a, b) -> a.marks() - b.marks() you never say which method you are writing. Java has to work that out, and it can only do that when there is one method to choose.

   Comparator has compare and nothing else abstract, so there is no question. An interface with two abstract methods could not be a lambda, because your code would not say which of the two you meant.

2. An anonymous class and a lambda do the same job here. What is different about the two on disk?

   Show the answer

   The anonymous class becomes a real file. Compile a class that holds one and you get Outer$1.class sitting next to Outer.class. Ten anonymous classes means ten extra files.

   The lambda produces no file at all. Nothing is written for it, and no class with that shape exists until the line actually runs.

   You can see it in the bytecode. The anonymous class compiles to new Outer$1 followed by a constructor call, which is an ordinary object being built. The lambda compiles to one instruction, invokedynamic, which says "make me something that fits here" and leaves the rest until run time.

3. Your class needs to be sorted three different ways by three different parts of the program. Why is `Comparable` the wrong tool?

   Show the answer

   Because Comparable puts the order inside the class, and a class can only hold one compareTo.

   That is right when there is a single obvious order, like an id. It is wrong the moment the teacher wants marks, the office wants names, and the report wants roll numbers. You cannot write three compareTo methods, and picking one of the three leaves the other two stuck.

   Comparator moves the order out. The order becomes something you pass in at the moment you sort, so the class stays light and each caller brings its own answer.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises85 pointsabout 90 minutes

import java.util.*;

public class ThreeOrders {
    record Student(String name, int rollNumber, int marks) { }

    public static void main(String[] args) {
        List<Student> students = new ArrayList<>(List.of(
            new Student("Aditya", 101, 85),
            new Student("Rohit",  102, 89),
            new Student("Rohan",  103, 93),
            new Student("Sonu",   104, 78)));

        // TODO: sort by name, print, using a named class that implements Comparator
        // TODO: sort by marks, print, using an anonymous class
        // TODO: sort by roll number, print, using a lambda
        // TODO: count the lines each one took
    }
}

import java.util.*;

public class Counting {
    record S(String name, int marks) { }

    public static void main(String[] args) {
        Comparator<S> viaAnon = new Comparator<S>() {
            public int compare(S x, S y) { return Integer.compare(x.marks(), y.marks()); }
        };
        Comparator<S> viaLambda = (x, y) -> Integer.compare(x.marks(), y.marks());

        // TODO: print getClass().getName() for both. Read the two names carefully.
        // TODO: check both with instanceof Comparator
    }
}

public class OneMethod {

    interface Job {
        void run(String input);
    }

    // TODO: add a second abstract method to Job. Try to keep the lambda below. Read the error.
    // TODO: undo that, and add a DEFAULT method instead. Does the lambda still work?
    // TODO: add a static method too. Does that break it?

    public static void main(String[] args) {
        Job j = input -> System.out.println("doing " + input);
        j.run("the washing");
    }
}

import java.util.*;
import java.util.function.*;

public class Capture {

    static Supplier<String> makeGreeter() {
        String greeting = "hello";
        // TODO: return a lambda that uses greeting. This works. Why?
        return null;
    }

    public static void main(String[] args) {
        System.out.println(makeGreeter().get());

        int limit = 50;
        List<Integer> marks = new ArrayList<>(List.of(30, 60, 90));

        // TODO: a lambda using limit. Fine.
        // TODO: now assign limit = 60 somewhere and watch this stop compiling
        // TODO: get the same effect anyway, using an array or a field
    }
}