Java - Method References

---

---

What are Method References?

Method references were introduced in Java 8. Method reference is a special type of lambda expression. It fulfils the purpose of a lambda expression by increasing the readability and to write a neat code.

A method reference works in case of functional interfaces. Wherever, we are calling a method of a functional interface with a lambda expression, we can use a method reference.

Method references help to point to methods by their names even without specifying the arguments. Arguments are passed by the lambda expression. A method reference is described using the "::" symbol.

Why Use Method References?

In the following use cases, we can use method references in Java −

• Using the method reference in our code makes it easier to understand, and it increases the readability.
• The Method references support the functional programming style, which makes it easier to work with streams and collections.
• The chances of logical and typo errors are lower, and as no boilerplate is required, reusability increases as we use the existing methods.

Types of Java Method References

A method reference can be used to point to the following types of methods −

• Static Methods
• Instance Method of a Particular Object
• Instance Method of an Arbitrary Object
• Constructors using New operator (TreeSet::new)

Method Reference for Static Method

A static method can be referred using "::" symbol easily without creating any instance of the class, and by using the class name.

Syntax

<<class-name>>::methodName

Example: Reference to a Static Method

In this example, we are referencing the static method of our class to print the elements in three ways. The first approach is a regular approach to print the elements using a for loop. The second approach is to use a lambda expression in a for-each loop. The third approach is using a method reference in a for-each loop to print all the elements.

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;

public class Tester {
   public static void main(String args[]) {
      List<String> names = new ArrayList<>();

      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");

      System.out.println("Printing using for each loop");
      // Approach 1: for loop to print all elements
      for (String name: names) {
         System.out.println(name);
      }

      System.out.println("Printing using for each loop with lambda expression");
      // Approach 2: lambda expression to print the elements in for each loop
      names.forEach(s->System.out.println(s));

      System.out.println("Printing using for each loop with method reference" );
      // Approach 3: Method reference to print elements in for each loop
      names.forEach(System.out::println);
   }
}

Output

Let us compile and run the above program. This will produce the following result −

Printing using for each loop
Mahesh
Suresh
Ramesh
Naresh
Kalpesh
Printing using for each loop with lambda expression
Mahesh
Suresh
Ramesh
Naresh
Kalpesh
Printing using for each loop with method reference
Mahesh
Suresh
Ramesh
Naresh
Kalpesh

Method Reference for the Instance Method of a Particular Object

Similar to static methods, we can refer to an instance method of a particular object using a Method reference. This is referred to as calling an instance method on a specific, existing object.

Syntax

<<object-name>>::methodName

Example: Instance Method of a Particular Object

In this example, we are referencing the instance method of the Integer class to compare the elements in two ways. The first approach is a regular approach to compare the elements using the sorted method with a lambda expression having an explicit method call. The second approach is using the method reference for the instance method of a particular object.

package com.tutorialspoint;

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

class Number_Comparator {
   public int compare(Integer a, Integer b) {
      return a.compareTo(b);
   }
}

public class Tester {
   public static void main(String args[]) {
      List<Integer> numbers = Arrays.asList(1,2,4,9,8,7,3);
      System.out.println("Sorted using lambda expression");
      numbers = numbers.stream().sorted((a,b) -> a.compareTo(b)).toList();

      System.out.println(numbers);

      numbers = Arrays.asList(1,2,4,9,8,7,3);
      Number_Comparator number_Comparator = new Number_Comparator();
      System.out.println("Sorted using method reference");
      numbers = numbers.stream().sorted(number_Comparator::compare).toList();

      System.out.println(numbers);		
   }
}

Output

Let us compile and run the above program. This will produce the following result −

Sorted using lambda expression
[1, 2, 3, 4, 7, 8, 9]
Sorted using method reference
[1, 2, 3, 4, 7, 8, 9]

Method Reference for the Instance Method of an Arbitrary Object

Similar to an instance method for a particular object, we can refer to an instance method of an arbitrary object using a Method reference. This is referred to as calling an instance method on any object of a particular type that is already passed as a parameter.

Syntax

<<object-type>>::methodName

Example: Instance Method of an Arbitrary Object

In this example, we are referencing the instance method of the Integer class to compare the elements in two ways. The first approach is a regular approach to compare the elements using the sorted method with a lambda expression having an explicit method call. The second approach is using the method reference for the instance method of an arbitrary object.

package com.tutorialspoint;

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

public class Tester {
   public static void main(String args[]) {
      List<Integer> numbers = Arrays.asList(1,2,4,9,8,7,3);
      System.out.println("Sorted using lambda expression");
      numbers = numbers.stream().sorted((a,b) -> a.compareTo(b)).toList();

      System.out.println(numbers);

      numbers = Arrays.asList(1,2,4,9,8,7,3);
      System.out.println("Sorted using method reference" );
      numbers = numbers.stream().sorted(Integer::compareTo).toList();

      System.out.println(numbers);		
   }
}

Output

Let us compile and run the above program. This will produce the following result −

Sorted using lambda expression
[1, 2, 3, 4, 7, 8, 9]
Sorted using method reference
[1, 2, 3, 4, 7, 8, 9]

Method Reference for Constructor

We can use a method reference to invoke a constructor as well. This is similar to static method invocation, but here we're using new instead of the method name.

Syntax

<<class-name>>::new

Example: Reference to a Constructor

In this example, we are creating new objects of the Student class based on the names of the students while iterating over the list of student names.

package com.tutorialspoint;

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

public class Tester {
   public static void main(String args[]) {
      List<String> studentNames = Arrays.asList("Mahesh","Suresh","Ramesh","Robert","Jon");

      // create the list of student objects from names
      Student[] students =  studentNames.stream().map(Student::new).toArray(Student[]::new);

      List<String> list = Arrays.asList(students);

      System.out.println(list);
   }
}

class Student{
   String name;
   Student(String name){
      this.name = name;
   }
   public String toString(){
      return this.name;
   }
}

Output

Let us compile and run the above program. This will produce the following result −

[Mahesh, Suresh, Ramesh, Robert, Jon]