method-reference

This question already has an answer here: How to indirectly run a method reference in Java 8? 2 answers This question is pretty closely related to another one . However, I feel like the accepted answer to that question is not quite as definitive. So, what is the type of a method reference in Java 8? Here's a little demonstration of how a method reference can be "cast" (lifted?) into a java.util.function.Function : package java8.lambda; import java.util.function.Function; public class Question { public static final class Greeter { private final String salutation; public Greeter(final String

I'm learning about Method References from Java 8 and I have difficulties understanding why does this work? class Holder { private String holded; public Holder(String holded) { this.holded = holded; } public String getHolded() { return holded; } } private void run() { Function<Holder, String> getHolded = Holder::getHolded; consume(Holder::getHolded); //This is correct... consume(getHolded); //...but this is not } private void consume(Consumer<Holder> consumer) { consumer.accept(null); } As you can see in run method - Holder::getHolded returns unbound method reference which you can invoke by

I have this class called Container : public class Container { private final Map<String, Object> map = new HashMap<>(); public void put(String name, Object value) { map.put(name, value); } public Container with(String name, Object value) { put(name, value); return this; } public Object get(String name) { return map.get(name); } public <R> R get(String name, Function<Object, R> mapper) { Object value = get(name); if (null == value) { return null; } return mapper .apply(value); } public <R> R get(String name, Class<R> type) { Object value = get(name); if (null == value) { return null; } if (type

Consider the following class: import java.util.Objects; import java.util.function.Predicate; public class LambdaVsMethodRef { public static void main(String[] args) { Predicate<Object> a = Objects::nonNull; Predicate<Object> b = x -> x != null; } } The first predicate is created from a method reference and the other a lambda expression. These predicates have the same behavior ( nonNull 's body is just return obj != null; ). The lambda is two characters shorter (perhaps allowing a stream pipeline to fit on one line). Other than code style, is there any difference between Objects::nonNull and x

I'm wondering how does all this stuff with method references and functional interfaces works on lower level. The easiest example is where we have some List List<String> list = new ArrayList<>(); list.add("b"); list.add("a"); list.add("c"): Now we want to sort it with Collections class, so we can call: Collections.sort(list, String::compareToIgnoreCase); But if we define custom comparator it could be something like: Comparator<String> customComp = new MyCustomOrderComparator<>(); Collections.sort(list, customComp::compare); The problem is that Collections.sort takes two parameters: List and

Is there a way in Java8 to use a method reference as a Function object to use its methods, something like: Stream.of("ciao", "hola", "hello") .map(String::length.andThen(n -> n * 2)) This question is not related to the Stream , it is used just as example, I would like to have answer about the method reference You can write a static method to do this: import java.util.function.*; class Test { public static void main(String[] args) { Function<String, Integer> function = combine(String::length, n -> n * 2); System.out.println(function.apply("foo")); } public static <T1, T2, T3> Function<T1, T3>

Say we have a variable of type IntFunction that returns an integer array: IntFunction<int[]> i; With Java 8 generics, it is possible to initialize this variable with a constructor reference like this: i = int[]::new How does the Java compiler translate this to bytecode? I know that for other types, like String::new , it can use an invokedynamic instruction that points to the String constructor java/lang/String.<init>(...) , which is just a method with a special meaning. How does this work with arrays, seeing that there are special instructions for constructing arrays? You can find out yourself

I was reading about Java 8 features, which lead me to this article and I was wondering about the actual uses of constructor reference, I mean why not just use new Obj ? P.S, I tried googling, but I failed to find something meaningful, if someone has a code example, link or tut it will be great Holger First of all, you should understand that constructor references are just a special form of method references. The point about method references is that they do not invoke the referenced method but provide a way to define a function which will invoke the method when being evaluated. The linked

I have group of students. First I want to group them by the marks. Then I want to further group those sets into same name students together. Map<Integer,Map<String,List<String>>> groupping = students.stream() .collect(Collectors.groupingBy(Student::getMarks, Collectors.mapping(Student::getName,Collectors.toList()))); I am getting a error saying, Non-static method cannot be refered from a static context. Yes. I am pretty much aware that I cannot refer a non-static method without having an instance. But with all these stream operations, I'm bit confused what has gone wrong really. Rather than