Java 8 Method References Explained: Examples and Best Practices

Java introduced method references in Java 8 as a part of the lambda expressions feature. Method references provide a shorthand syntax to refer to methods without having to explicitly invoke them. This can make your code cleaner and easier to read.

What are Method References?

Method references are a way to refer to a method without executing it. They are used to make your code more concise by replacing some lambda expressions with a method reference. The general syntax for method references is ClassName::methodName.

Types of Method References

There are four types of method references in Java:

1. Reference to a Static Method
2. Reference to an Instance Method of a Particular Object
3. Reference to an Instance Method of an Arbitrary Object of a Particular Type
4. Reference to a Constructor

Let’s look at each of these types in detail with examples.

1. Reference to a Static Method

You can refer to a static method using the class name and the method name. The syntax is ClassName::staticMethodName.

Example

import java.util.function.Function;

public class MethodReferenceExample {
    public static void main(String[] args) {
        // Using a lambda expression
        Function<String, Integer> lambdaFunction = s -> Integer.parseInt(s);

        // Using a method reference
        Function<String, Integer> methodRefFunction = Integer::parseInt;

        // Testing the method reference
        System.out.println("Lambda result: " + lambdaFunction.apply("123"));
        System.out.println("Method reference result: " + methodRefFunction.apply("123"));
    }
}

In this example, Integer::parseInt is a method reference to the static method parseInt of the Integer class.

2. Reference to an Instance Method of a Particular Object

You can refer to an instance method of a particular object using the syntax instance::instanceMethodName.

Example

import java.util.function.Supplier;

public class MethodReferenceExample {
    public static void main(String[] args) {
        String message = "Hello, World!";

        // Using a lambda expression
        Supplier<String> lambdaSupplier = () -> message.toUpperCase();

        // Using a method reference
        Supplier<String> methodRefSupplier = message::toUpperCase;

        // Testing the method reference
        System.out.println("Lambda result: " + lambdaSupplier.get());
        System.out.println("Method reference result: " + methodRefSupplier.get());
    }
}

In this example, message::toUpperCase is a method reference to the instance method toUpperCase of the message object.

3. Reference to an Instance Method of an Arbitrary Object of a Particular Type

You can refer to an instance method of an arbitrary object of a particular type using the syntax ClassName::instanceMethodName.

Example

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");

        // Using a lambda expression
        words.forEach(word -> System.out.println(word));

        // Using a method reference
        words.forEach(System.out::println);
    }
}

In this example, System.out::println is a method reference to the instance method println of the PrintStream object System.out.

4. Reference to a Constructor

You can refer to a constructor using the syntax ClassName::new. This is often used with functional interfaces that create new objects.

Example

import java.util.function.Function;

class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "'}";
    }
}

public class MethodReferenceExample {
    public static void main(String[] args) {
        // Using a lambda expression
        Function<String, User> lambdaFunction = name -> new User(name);

        // Using a method reference
        Function<String, User> methodRefFunction = User::new;

        // Testing the method reference
        User user1 = lambdaFunction.apply("Alice");
        User user2 = methodRefFunction.apply("Bob");

        System.out.println("Lambda result: " + user1);
        System.out.println("Method reference result: " + user2);
    }
}

In this example, User::new is a method reference to the constructor of the User class.

Benefits of Method References

• Conciseness: Method references make the code shorter and more readable.
• Reusability: They allow reusing existing method definitions rather than writing new lambda expressions.
• Clarity: The intent of the code is clearer when method references are used.

Conclusion

Method references in Java are a powerful feature that simplifies the use of methods as first-class citizens in functional programming. By understanding the four types of method references, you can write more concise and readable code. Try refactoring some of your lambda expressions into method references to see the benefits for yourself!