Java Method References: The Beginner's Guide

By NIIT Editorial

Published on 21/06/2023

A lambda is an anonymous function that may be passed around like any other object in Java, and a reference to a method is a shortcut syntax for constructing lambdas. You may avoid writing a lambda expression that just calls a method by referring to it by its name using a method reference.

Java method references are useful because they reduce complexity and enhance readability. Method references simplify the process of writing and maintaining code by offering a shorthand syntax for calling upon previously defined procedures. By eliminating the need to create a new lambda expression for each function call, they may also improve code efficiency.

In functional programming, functions are given the same respect as other types of code, hence references to methods are quite helpful. They let you design higher-order functions that take functions as input and return functions as output, as well as send functions as parameters to other functions.


Table of Contents:

  • Method References in Java
  • Using Method References
  • Advantages of Method References
  • Limitations of Method References
  • Conclusion



Method References in Java

1. Reference to a Static Method 

The referenced method is a class's static method. ClassName::methodName is the correct notation for this.


2. Reference to an Instance Method of a Particular Object

This sort of method reference specifies a particular object's instance method. You may also express it in the form object::methodName.


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

Instance methods of objects of a certain type are what this kind of method reference denotes. ClassName::methodName is the correct notation for this.


4. Reference to a Constructor 

A class's function Object() { [native code] } is being referred to by this method type. The syntax looks like this: ClassName::new.

A reference to a method may be used in a method that takes a functional interface as an argument (an interface with a single abstract method). The method's reference will be transformed into an instance of the relevant interface so that it may be utilised as a function object. In functional programming and other scenarios, passing a reference to an existing method as a function parameter may be quite helpful.


Using Method References


1. Reference Syntax for Methods

References to methods have the following syntax:


Copy code





ClassName is the name of the class containing the method, object is an instance of the class, methodName is the name of the method, and new is the keyword used for constructors.


Method Reference Examples

Several common references to methods are shown below:

  • Reference to a Static Method:


             Copy code

             // Using lambda expression


            sort(arr, (a, b) -> Integer.

            compare(a, b));

           // Using method reference

          Arrays.sort(arr, Integer::compare);


  • Reference To an Instance Method of a Particular Object:


             Copy code

             // Using lambda expression

             List<String> list = Arrays.asList("apple", "banana", "orange");

             list.forEach(str -> System.out.println(str.toUpperCase()));

             // Using method reference

            List<String> list = Arrays.asList("apple", "banana", "orange");



  • Reference to an Instance Method of an Arbitrary Object of a Particular Type:


             Copy code

             // Using lambda expression

             List<String> list = Arrays.asList("apple", "banana", "orange");

             list.sort((a, b) -> a.compareToIgnoreCase(b));

             // Using method reference

            List<String> list = Arrays.asList("apple", "banana", "orange");



  • Reference to a Constructor:


             Copy code

             // Using lambda expression

             Supplier<List<String>> supplier = () -> new ArrayList<>();

            // Using method reference

            Supplier<List<String>> supplier = ArrayList::new;


2. Best Practices for Using Method References:

Here are some best practices for using method references:

  • In order to reduce complexity and increase readability, reference methods.
  • When the lambda expression only includes a single method call, use a reference to that method.
  • Complex or multi-line techniques should not be referred to by reference.
  • Method references of the right kind should be used.
  • References to methods having side effects should be avoided since they might cause confusion and unexpected behaviour.
  • Lambda expressions are simpler and clearer than method references, therefore use them wherever possible.


Advantages of Method References

The advantages of using method references in Java are:

  • Code Simplification: By eliminating the need to repeatedly define common functionality when working with anonymous classes, method references greatly aid in the simplification of code.
  • Improved Readability: By highlighting the relevant parts of the code, method references improve readability. Particularly relevant are method references that point to frequently used methods like System. out::println.
  • Reusability: By declaring a method reference just once and then utilising it in various places, you can easily construct code that can be reused.
  • Improved Performance: In certain circumstances, such when working with the Java Stream API, using a reference to a previously defined method might be quicker than using a lambda expression.
  • Better Type Checking: The Java compiler can do more thorough type checking and catch more problems at compile time when referencing methods because to the language's strong typing.
  • Easier Debugging: If you're having trouble debugging certain code, you may find that using method references helps.



Limitations of Method References

Java 8 and subsequent versions include the method reference, a short and potent way to refer to a method as a value. Yet, they are not without their restrictions:


1. Limited to Functional Interfaces 

Functional interfaces, which contain just a single abstract method, are the only types that may make use of method references. So, you can't utilise a reference to a method in an interface or class that doesn't really do anything.


2. Limited to Certain Method Signatures

References to methods may only be utilised for those that have the same signature as the corresponding functional interface. If the functional interface accepts one parameter, then that same number of arguments must be accepted by the referenced method.


3. Lack of Context

The local variable values and other call-time details are lost in a reference to a method. Because of this, there are several cases in which using method references is problematic.


4. Limited to Instance or Static Methods 

Only instance methods and static methods may be referenced by another method. They can't be utilised with primitive-type parameter-accepting constructors or methods.


5. Reduced Readability 

When used in conjunction with complicated lambda expressions or when the referred method has a lengthy or confusing name, method references might reduce the readability of the code. A lambda expression or unnamed inner class might be more appropriate in such circumstances.



Finally, if you want to write code that is both efficient and easy to maintain, you need to know how to reference methods in Java. References to methods as values are both simple and powerful, but it's important to keep in mind that they have their own set of constraints. 

Participating in a Java developer course is a great way to get insight into Java's method references and other useful features. Enroll in a Java development course right now and put yourself in a position to succeed in the field.