All 15 Functional Interfaces & Method References questions
More in Functional Interfaces & Method References
What is a functional interface, and what are the four core functional interfaces in java.util.function (Function, Predicate, Consumer, Supplier)? How do the default methods andThen() and compose() on Function work, and what's the difference between them for chaining transformations? What is the difference between UnaryOperator<T> and Function<T,T>, and why does UnaryOperator exist as a separate, more specific interface? How do the primitive-specialized functional interfaces (IntFunction, ToIntFunction, IntPredicate, IntUnaryOperator, etc.) avoid the performance cost of autoboxing, and when should you prefer them over the generic equivalents? How does the Predicate interface's default methods and(), or(), and negate() enable composing complex boolean conditions from simpler ones? What is the difference between a Consumer<T> and a BiConsumer<T,U>, and how would you use BiConsumer for operations needing two inputs but no return value, such as Map.forEach()? How would you convert a checked-exception-throwing method into a lambda usable with a standard functional interface (which doesn't declare any checked exceptions), given standard interfaces like Function don't permit checked exceptions in their abstract method signature? How does a lambda expression capture variables from its enclosing scope, and why must captured local variables be effectively final? How would you implement a custom functional interface with generic type parameters, and what considerations apply when designing one instead of reusing a built-in java.util.function interface? How would you implement memoization (caching function results) as a higher-order function wrapping an existing Function, and what thread-safety considerations apply for a memoized function used concurrently?
Advertisement
Java › Functional Interfaces & Method References

What are the four kinds of method references in Java (static, instance-bound, instance-unbound, and constructor), and how does the compiler determine which form applies?

Intermediate

Answer

Static method reference (ClassName::staticMethod) refers to a static method; bound instance method reference (instance::method) refers to a specific, already-existing object's instance method; unbound instance method reference (ClassName::instanceMethod) refers to an instance method where the first functional interface parameter becomes the receiver object the method is called on; constructor reference (ClassName::new) refers to a constructor -- the compiler determines which form applies based on the functional interface's method signature being targeted, matching parameter types and count against the referenced method/constructor's own signature.
// Static
Function<String, Integer> parse = Integer::parseInt;

// Bound instance (specific object 'str')
String str = "hello";
Supplier<Integer> len = str::length;

// Unbound instance (first param becomes the receiver)
Function<String, Integer> len2 = String::length;  // equivalent to s -> s.length()

// Constructor
Supplier<ArrayList<String>> listMaker = ArrayList::new;
Real-world example A stream pipeline transforming a list of raw strings into parsed integers uses the static method reference Integer::parseInt, while a separate pipeline extracting each string's length uses the unbound instance reference String::length, both more concise and readable than the equivalent explicit lambda expressions.

Common follow-ups: How would you write the unbound instance method reference example as an equivalent explicit lambda?;What happens if a method reference is ambiguous between multiple overloaded methods with the same name?

Streams & Lambdas;OOP & Classes
All 15 Functional Interfaces & Method References questions