method-reference

public class Main { interface Capitalizer { public String capitalize(String name); } public String toUpperCase() { return "ALLCAPS"; } public static void main(String[] args) { Capitalizer c = String::toUpperCase; //This works c = Main::toUpperCase; //Compile error } } Both are instance methods with same signature. Why does one work and the other doesn't? Signature of String::toUpperCase : String toUpperCase(); gniewkos There are 3 constructs to reference a method: object::instanceMethod Class::staticMethod Class::instanceMethod The line: Capitalizer c = String::toUpperCase; //This works use 3

I'm a little bit confused about Java lambdas and method references behaviour. For ex., we have this code: import java.util.function.Consumer; public class Main { private static StringBuilder sBuilder = new StringBuilder("1"); public static void main(String[] args) { Consumer<String> consumer = s -> sBuilder.append(s); sBuilder = new StringBuilder("2"); consumer.accept("3"); System.out.println(sBuilder); } } Output: 23 This works as expected, but if we replace s -> sBuilder.append(s) with sBuilder::append the output will be: 2 Have you any ideas how to explain this? This isn't the same things?

Suppose I do this in jshell: jshell> void printIsEven(int i) { ...> System.out.println(i % 2 == 0); ...> } | created method printIsEven(int) jshell> List<Integer> l = Arrays.asList(7,5,4,8,5,9); l ==> [7, 5, 4, 8, 5, 9] jshell> l.forEach(/* ??? */); // is it possible to use a method reference here? In a normal program I could write l.forEach(this::printIsEven) in a non-static context or l.forEach(MyClass::printIsEven) in the static context of a class named MyClass . Using this::printIsEven in jshell doesn't work because jshell executes statements in a static context, but you can't use a static

This question already has an answer here: Instance Method Reference and Lambda Parameters 2 answers The oracle Java 8 documentation defines 4 types of method references you can use instead of Lambda Expressions. What I am trying to understand is the kind of method reference described as: "Reference to an instance method of an arbitrary object of a particular type " which is written as ContainingType::methodName . I am not sure if I am missing something, but to me it seems more like: "Reference to the first parameter of the abstract method of the Functional Interface, assuming it is of type

How does Java know which String::compareTo method reference to use when calling Collections.sort(someListOfStrings, String::compareTo); ? compareTo is not static and it needs to know the value of the "left hand side" of the comparison. Suppose that you use method reference for Comparator interface: Comparator<String> cmp = String::compareTo; When you call the cmp.compare(left, right) (which is "single abstract method" or "SAM" of Comparator interface), the magic occurs: int result = cmp.compare(left, right); | | /------------------------/ | | /---------------/ | | left.compareTo(right);

I've come across a strange error message that I believe may be incorrect. Consider the following code: public class Overloaded { public interface Supplier { int get(); } public interface Processor { String process(String s); } public static void load(Supplier s) {} public static void load(Processor p) {} public static int genuinelyAmbiguous() { return 4; } public static String genuinelyAmbiguous(String s) { return "string"; } public static int notAmbiguous() { return 4; } public static String notAmbiguous(int x, int y) { return "string"; } public static int strangelyAmbiguous() { return 4; }

In the following code, it works when passing the method reference variable with the class name, but when passing the reference variable with a user object there is an error. public class User { private String name; public User(String name) { this.name = name; } public void printName() { System.out.println(name); } } public class Main { public static void main(String[] args) { User u1 = new User("AAA"); User u2 = new User("BBB"); User u3 = new User("ZZZ"); List<User> userList = Arrays.asList(u1, u2, u3); userList.forEach(User::printName); // works userList.forEach(u1::printName); // compile