Method References and the Four Shapes

Java answers both problems at once. It ships the interfaces, and it lets you drop the courier.

Four interfaces cover almost everything. They live in java.util.function, and they differ only in what goes in and what comes out.

Function<String, Integer> length   = s -> s.length();
Predicate<String>         isLong   = s -> s.length() > 4;
Supplier<List<String>>    fresh    = () -> new ArrayList<>();
Consumer<String>          show     = s -> System.out.println(s);

length.apply("hello");   // 5
isLong.test("hi");       // false
fresh.get();             // a new empty list
show.accept("printed");  // prints

Predicate is a Function that answers yes or no. It gets its own name because asking yes or no questions is common enough to be worth one.

There are about forty in the package. All of them are variations: two arguments instead of one (BiFunction), primitives instead of objects (IntPredicate), same type in and out (UnaryOperator). Learn the four and the rest are lookups.

Now drop the courier. When a lambda does nothing but pass its argument to an existing method, name the method instead:

n -> System.out.println(n)      becomes    System.out::println
s -> Integer.parseInt(s)        becomes    Integer::parseInt
s -> s.toUpperCase()            becomes    String::toUpperCase
() -> new ArrayList<>()         becomes    ArrayList::new

That is a method reference. Two colons, and the parameter list disappears because it was only ever repeating itself.

There are four kinds, and the third is the one that confuses people.

And they join together. These interfaces have default methods, which is the Section 8.5 feature that let Java add to an interface without breaking anyone:

Function<Integer, Integer> addTwo = x -> x + 2;
Function<Integer, Integer> triple = x -> x * 3;

addTwo.andThen(triple).apply(2);   // 12. add first, then multiply
addTwo.compose(triple).apply(2);   // 8.  multiply first, then add

andThen runs left to right. compose runs right to left. Same two functions, same input, different answers, and neither one is an error.

Predicates join up too:

Predicate<String> isLong = s -> s.length() > 4;
Predicate<String> hasA   = s -> s.contains("a");

isLong.and(hasA).test("banana");   // true
isLong.and(hasA).test("bond");     // false
isLong.or(hasA).test("cat");       // true
isLong.negate().test("hi");        // true

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

1. `Function`, `Predicate`, `Supplier`, `Consumer`. What single question separates them?

   Show the answer

   What goes in and what comes out.

   Function takes one and returns something else. String in, Integer out. Its method is apply.

   Predicate takes one and returns a boolean. It is a Function whose answer is always yes or no, which is common enough to deserve a name. Its method is test.

   Supplier takes nothing and returns something. Its method is get.

   Consumer takes one and returns nothing. It exists to do something, not to answer. Its method is accept.

   Every one of the forty is a variation on those four. Once you can name the shape you need, finding the interface is a lookup.

2. `addTwo.andThen(multiplyByThree)` and `addTwo.compose(multiplyByThree)` both build one function from two. Which does what?

   Show the answer

   andThen runs left to right. addTwo.andThen(multiplyByThree) applied to 2 gives 12: add first, then multiply.

   compose runs right to left. addTwo.compose(multiplyByThree) applied to 2 gives 8: multiply first, then add.

   Same two functions, same input, two different answers, and no error either way. If you cannot remember which is which, use andThen everywhere. It reads in the order the work happens, which is the order you were thinking in.

   Both take a function and return a function. That is what lets them chain.

3. Why does `IntUnaryOperator` exist when `Function<Integer, Integer>` already works?

   Show the answer

   Because Function<Integer, Integer> cannot hold an int. Generics only work with objects, from Section 9.3, so every call boxes the input into an Integer and unboxes the answer.

   Fifty million calls, measured: 204 ms for Function<Integer, Integer> against under 1 ms for IntUnaryOperator.

   The gap is not the arithmetic. It is fifty million Integer objects being made and thrown away. IntUnaryOperator takes an int and returns an int, so nothing is allocated at all.

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

4 exercises90 pointsabout 95 minutes

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

public class Shapes {
    public static void main(String[] args) {
        // For each job below, write down IN, OUT, then pick the interface,
        // then write the lambda. Do it in that order every time.

        // TODO: turn a String into its length
        // TODO: answer whether a String is longer than 4
        // TODO: make a brand new empty ArrayList
        // TODO: print a String to the screen
        // TODO: add two ints together        (what is different about this one?)
        // TODO: turn a Student into its name (what are IN and OUT here?)
    }
}

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

public class Colons {
    static String shout(String s) { return s.toUpperCase() + "!"; }

    public static void main(String[] args) {
        String greeting = "hello";

        // Write each one FIRST as a lambda, THEN as a method reference.
        // TODO: a static method            (Integer.parseInt)
        // TODO: a method on one object     (System.out.println, greeting.length)
        // TODO: a method on any object     (String.toUpperCase)
        // TODO: a constructor              (new ArrayList<>)

        // TODO: String::toUpperCase takes no arguments, but Function supplies one.
        //       Work out where that argument went, and write the answer in a comment.
    }
}

import java.util.function.*;

public class Chain {
    public static void main(String[] args) {
        Function<Integer, Integer> addTwo = x -> x + 2;
        Function<Integer, Integer> triple = x -> x * 3;

        // TODO: predict both BEFORE running, and write your predictions down
        // System.out.println(addTwo.andThen(triple).apply(2));
        // System.out.println(addTwo.compose(triple).apply(2));

        // TODO: chain three together and predict again
        // TODO: build the pipeline on one line and apply it on another.
        //       Print something in between. When does the arithmetic happen?

        Predicate<String> isLong = s -> s.length() > 4;
        Predicate<String> hasA   = s -> s.contains("a");
        // TODO: and, or, negate. Predict each before running
    }
}

import java.util.function.*;

public class Boxing {
    public static void main(String[] args) {
        int n = 50_000_000;

        Function<Integer, Integer> boxed = x -> x + 1;
        IntUnaryOperator           prim  = x -> x + 1;

        // TODO: time n calls to each. Run the whole thing three times.
        // TODO: print both timings each round and watch what happens to the boxed one
        // TODO: work out how many objects the boxed version created
        // TODO: find the primitive version of Predicate and of Function, and name them
    }
}