Java 8 streams, why does this compile part 2... Or what is a method reference, really?

Question

OK, the first question in this "series" was this one.

Now, here is another case:

Arrays.asList("hello", "world").stream().forEach(System.out::println);

This compiles, and works...

OK, in the last question, static methods from a class were used.

But now this is different: System.out is a static field of System, yes; it is also a PrintStream, and a PrintStream has a println() method which happens to match the signature of a Consumer in this case, and a Consumer is what forEach() expects.

So I tried this...

public final class Main
{
    public static void main(final String... args)
    {
        Arrays.asList(23, 2389, 19).stream().forEach(new Main()::meh);
    }

    // Matches the signature of a Consumer<? super Integer>...
    public void meh(final Integer ignored)
    {
        System.out.println("meh");
    }
}

And it works!

This is quite a different scope here, since I initiate a new instance and can use a method reference right after this instance is constructed!

So, is a method reference really any method which obeys the signature? What are the limits? Are there any cases where one can build a "@FunctionalInterface compatible" method which cannot be used in a @FunctionalInterface?

You should really read the [State of Lambda](http://cr.openjdk.java.net/~briangoetz/lambda/lambda-state-final.html) starting at Section 8: Method References — Edwin Dalorzo, Mar 26 '14 at 14:00
It shouldn't be surprising, since you can do `new Main().meh(42)` — David Conrad, Apr 04 '14 at 20:52
Should probably have used the "Reward existing answer" bounty reason instead of "Draw attention". No biggie, though. — Michael Myers, Dec 24 '14 at 17:20

score 20 · Accepted Answer · edited Jul 29 '14 at 08:36

The syntax of method references is defined in JLS #15.13. In particular it can be of the form:

Primary :: [TypeArguments] Identifier

Where Primary can be, among other things, a:

ClassInstanceCreationExpression

so yes, your syntax is correct. A few other interesting examples:

this::someInstanceMethod    // (...) -> this.someInstanceMethod(...)
"123"::equals               // (s) -> "123".equals(s)
(b ? "123" : "456")::equals // where b is a boolean
array[1]::length            // (String[] array) -> array[1].length()
String[]::new               // i -> new String[i]
a.b()::c                    // (...) -> a.b().c(...)

By the way, since you mention static methods, it is interesting to note that you can't create a static method reference from an instance:

class Static { static void m() {} }
Static s = new Static();

s.m(); //compiles
someStream.forEach(s::m); //does not compile
someStream.forEach(Static::m); //that's ok

Seems like I have a lot to learn... Thanks for the detailed answer! — fge, Mar 26 '14 at 14:25

score 4 · Answer 2 · answered Mar 26 '14 at 14:02

From the State of Lambda

Kinds of method references

There are several different kinds of method references, each with slightly different syntax:

A static method (ClassName::methName)

An instance method of a particular object (instanceRef::methName)

A super method of a particular object (super::methName)

An instance method of an arbitrary object of a particular type (ClassName::methName)

A class constructor reference (ClassName::new)

An array constructor reference (TypeName[]::new)

score 3 · Answer 3 · answered Mar 26 '14 at 13:57

Saying this:

something(new Main()::meh);

Is approximately equivalent to saying this:

Main x = new Main();
something(() -> x.meh());

Or this:

final Main x = new Main();
something(new Whatever() {
    public void meh(Integer ignored) {
        x.meh();
    }
}

The new instance is "captured" and used in the new lambda instance which was implicitly created from the method handle.

Java 8 streams, why does this compile part 2... Or what is a method reference, really?

3 Answers3

Linked