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 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 “::” symbol.

Types of Java Method References

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

• Static methods

• Instance methods

• 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 class name.

Syntax

<<class-name>>::methodName

Example: Reference to a Static Method

In this example, we’re referencing static method of out class to print the elements in three ways. First approach is regular approach to print the elements using for loop. Second approach is to use a lambda expression in for each loop. Third approach is using method reference in 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 Instance Method

Similar to static methods, we can refer to instance method of an object using Method reference.

Syntax

<<object-name>>::methodName

Example: Reference to an Instance Method

In this example, we’re referencing instance method of Integer class to compare the elements in two ways. First approach is regular approach to compare the elements using sorted method with a lambda expression having explicit method call. Second approach is using method reference.

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 method reference to invoke constructor as well. This is similar to static method invocation but here we”re using new instead of method name.

Syntax

<<class-name>>::new

Example: Reference to a Constructor

In this example, we’re creating new objects of Student class based on names of the students while iterating 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]