Java Streams：为什么我们可以在 map 中传递非静态方法引用

Question

I was wondering why we can pass method references even for methods that do not match the expected signature. How does the JVM know that it should call the method of the instance passed, rather than calling the method with the passed instance as first parameter. Here is an example of what I mean:

class Person {
    String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> listOfPeople = new ArrayList<>();
        listOfPeople.add(new Person("Mike"));
        listOfPeople.add(new Person("Tom"));

        // this makes perfect sense, since we pass a lambda with the signature Person -> String
        listOfPeople.stream().map(person -> person.getName()).forEach(System.out::println);
        // I know that this works but I don't understand why, the method passed has signature void -> String but java somehow knows to resolve it like on top.
        listOfPeople.stream().map(Person::getName).forEach(System.out::println);
    }
}

Answer 1

No void figures here.

Remember that Person::getName method reference of Function doesn't mean a transformation from void to String but Person to String`.

The map method requires a Function<T, R> where T is the original type ( Person in your case) and R stands for the transformation result type, which can be anything.

Notice the method public String getName() has String as the return type which is inferred into R and the parameter of the map method becomes Function<Person, String> regardless whether it is written as person -> person.getName() or Person::getName . They both mean the same.

Again, there is no void figuring.