مراجع الدوال (Method references)

Written Explanation

The idea

A method reference is written target::methodName, with two colons and no parentheses. It is shorthand for a lambda that forwards its parameters to that method. The Oracle Java Tutorials describe method references as compact, easy-to-read lambda expressions for methods that already have a name.

names.forEach(s -> System.out.println(s));   // lambda
names.forEach(System.out::println);          // method reference

Both create the same behavior. The target type decides how the parameters are passed on: forEach wants a Consumer<String>, so the method reference becomes "accept a string, call println with it".

The four forms

The Oracle tutorial lists the same four kinds. Let us look at each with one example.

1. Static method. Integer::parseInt is x -> Integer.parseInt(x). The parameters of the functional method are passed as arguments to the static method.

Function<String, Integer> parse = Integer::parseInt;

2. Method of a particular object. The object is named on the left, and it already exists, so every call uses that same object. System.out::println is the best-known case: System.out is one particular PrintStream.

Greeter g = new Greeter("Welcome");
Function<String, String> greet = g::greet;   // x -> g.greet(x)

3. Method of an arbitrary object of a type. The left side is a class name, but the method is an instance method. Then the first parameter becomes the object on which the method is called, and the remaining parameters become the arguments:

Function<String, Integer> len = String::length;                 // s -> s.length()
Comparator<String> ci = String::compareToIgnoreCase;           // (a, b) -> a.compareToIgnoreCase(b)

This is the one that confuses beginners, because String::length looks like a static call. It is not: there is no static String.length(...). The compiler reads it as "take a String and call its length". In compareToIgnoreCase the first string is the receiver and the second is the argument.

4. Constructor. Class::new creates a new object. Which constructor? The one whose parameters match the functional method:

Supplier<List<String>> make = ArrayList::new;       // () -> new ArrayList<>()
Function<String, Person> create = Person::new;      // name -> new Person(name)

ArrayList::new is a Supplier when there are no parameters, and could be a Function<Integer, ArrayList<...>> when there is one, because ArrayList has a constructor taking an initial capacity. The target type picks. (The tutorial also shows array constructor references, such as int[]::new; we will not need them.)

Static versus instance: the two-sentence test

When you see Name::method, ask: is method static?

• If yes, it is form 1: the parameters are the arguments.
• If it is an instance method and Name is a class, it is form 3: the first parameter is the receiver.

If Name is a variable or expression (System.out, g, this), it is form 2.

When to keep the lambda

Use a method reference when:

• The lambda does nothing but call one method with its parameters in the same order.
• The name reads better than the lambda body.

Keep the lambda when:

• It does more than forward: s -> s.length() > 4 has a comparison, so there is no method to point to. (If you want a reference, give the logic a name: static boolean isLong(String s) and then Main::isLong.)
• The parameters are reordered, or used twice, or combined with other values.
• The reference would be ambiguous or surprising to a reader. Clarity wins; the tutorial wording is "compact, easy-to-read", and a reference that makes people stop to puzzle it out has failed.

When the compiler complains

If the method does not exist or does not fit the functional interface, you get an error such as this, for a mistaken String::size:

Bad.java:4: error: invalid method reference
        Function<String, Integer> f = String::size;
                                      ^
  cannot find symbol
    symbol:   method size(String)
    location: class String

Check, in order: the name, whether it is static, and whether the number of parameters matches the interface method.