Course contentsShow
← Java
Lesson 1651 of 2,87035. Functional InterfacesFree lesson

Method References as Function Implementations

Using method references to create Function instances from existing methods.

Method References as Function Implementations

You'll learn: How to use method references as a shorthand for creating Function instances from existing methods.

The Core Idea

When you need a Function<T, R> that simply calls an existing method, you don't need to write a lambda expression. Java lets you reference the method directly using the :: operator. If a method takes one argument and returns a result, it naturally fits the Function interface's apply contract.

Think of it like this: instead of saying "take this input, call that method on it, and return the result," you can just say "use that method." It's a shorthand that makes your code cleaner and more readable.

How It Works

You've seen lambdas create Function instances:

Function<String, Integer> stringLength = s -> s.length();

But when the lambda just calls one existing method, use a method reference instead:

Function<String, Integer> stringLength = String::length;

Both are identical in behavior. The method reference String::length says "use the length method from the String class."

Types of Method References for Functions

Instance method reference:

Function<String, String> toUpper = String::toUpperCase;
String result = toUpper.apply("hello"); // "HELLO"

Static method reference:

Function<String, Integer> parser = Integer::parseInt;
Integer num = parser.apply("42"); // 42

Bound instance method reference:

String prefix = "Hello, ";
Function<String, String> greeter = prefix::concat;
String greeting = greeter.apply("World"); // "Hello, World"

Why Use Method References?

They reduce boilerplate when the lambda body would just forward to an existing method. More concise, easier to read, and signals intent clearly.

Key Takeaway: Method references using :: provide a clean, readable way to create Function instances from existing methods, eliminating the need for trivial lambda expressions that just forward calls.