From the Oracle method references tutorial: Reference to an Instance Method of an Arbitrary Object of a Particular Type The following is an example of a reference to an instance method of an arbitrary object of a particular type: String[] stringArray = { “Barbara”, “James”, “Mary”, “John”, “Patricia”, “Robert”, “Michael”, “Linda” }; Arrays.sort(stringArray, String::compareToIgnoreCase); The … Read more
The idea of the unbound receiver such as String::length is you’re referring to a method of an object that will be supplied as one of the lambda’s parameters. For example, the lambda expression (String s) -> s.toUpperCase() can be rewritten as String::toUpperCase. But bounded refers to a situation when you’re calling a method in a … Read more
Equivalent lambda expression of HighTemp::lessThanTemp is (highTemp1, highTemp2) -> { return highTemp1.lessThanTemp(highTemp2); } This is one of the features of Java8 named Reference to an Instance Method of an Arbitrary Object of a Particular Type Consider following example, interface FIface<T> { int testMethod(T a, T b); } class Test2 { private String str; Test2(String str) … Read more
You can’t use method references for this purpose. You have to resort to lambda expressions. The reason why the bind2 method of the linked question doesn’t work is that you are actually trying to bind two parameters to convert a three-arg function into a one-arg function. There is no similarly simple solution as there is … Read more
Unfortunately, the error message “Non-static method cannot be refered from a static context.” is just a place-holder for any type mismatch problem, when method references are involved. The compiler simply failed to determine the actual problem. In your code, the target type Map<Integer, Map<String, List<String>>> doesn’t match the result type of the combined collector which … Read more
A method reference is not a lambda expression, although they can be used in the same way. I think that is what is causing the confusion. Below is a simplification of how Java works, it is not how it really works, but it is close enough. Say we have a lambda expression: Runnable f = … Read more
In the first case (ArrayList::new) you are using the constructor which takes an initial capacity argument, in the second case you are not. A large initial capacity (index in your code) causes a large Object[] to be allocated, resulting in your OutOfMemoryErrors. Here are the two constructors’ current implementations: public ArrayList(int initialCapacity) { if (initialCapacity … Read more
No, method references do not support chaining. In your example it wouldn’t be clear which of the two methods ought to receive the second parameter. But if you insist on it… static <V,T,U> BiConsumer<V,U> filterFirstArg(BiConsumer<T,U> c, Function<V,T> f) { return (t,u)->c.accept(f.apply(t), u); } … BiConsumer<MyBean, String> c = filterFirstArg(List::add, MyBean::getList); The naming of the method … Read more
The example given from the Oracle Doc linked is: String[] stringArray = { “Barbara”, “James”, “Mary”, “John”, “Patricia”, “Robert”, “Michael”, “Linda” }; Arrays.sort(stringArray, String::compareToIgnoreCase); The lambda equivalent of String::compareToIgnoreCase would be (String a, String b) -> a.compareToIgnoreCase(b) The Arrays.sort() method is looking for a comparator as its second argument (in this example). Passing String::compareToIgnoreCase creates … Read more
myString::charAt would take an int and return a char, and might be used for any lambda that works that way. It translates, essentially, to index -> myString.charAt(index). String::length would take a String and return an int. It translates, essentially, to string -> string.length(). String::charAt would translate to (string, index) -> string.charAt(index).