A comprehensive guide to Java 8 method reference
Java 8 has introduced a lot of new features such as lambda expressions, stream, Method references etc.
In this post, we will see what are Method references and how can we use it. I will try to provide more examples rather than theory.
Introduction to Method Reference
Method references
are special types of lambda expressions that execute only one method.
General syntax of method reference:
object::methodName
You might have already guessed that you need to understand lambda expressions first. If you are comfortable with lambda expressions, then let’s move forward.
Let’s understand this with the help of example.
Let’s create class MethodReferecesLambdaExpressionMain
in which we are going to print list using stream's foreach method.
Output:
=======================
Using anonymous class
=======================
India
China
Nepal
Russia
=======================
Using lambda expression
=======================
India
China
Nepal
Russia
=======================
Using Method references
=======================
India
China
Nepal
Russia
stream.foreach()
method takes consumer functional interface as agrument.
Consumer is functional interface that takes a single argument and returns nothing.
We have used consumer functional interface in 3 ways.
1. Using anonymous class
Consumer consumer1 = new Consumer() {@Override
public void accept(String country) {
System.out.println(country);
}
};2. Using lambda expression
Consumer consumer2 = country -> System.out.println(country);3. Using method reference
Consumer consumer3 = System.out::println;You might already know that you can use lambda expression instead of an anonymous class, but You can use method reference only when the lambda expression just calls to a method.
So if you look at below syntax:Consumer consumer3 = System.out::println;
In method reference, we have Class or object before ::
and method name after ::
without arguments.
Did you notice the method reference does not have arguments?
Yes, we don’t need to pass arguments to method reference, arguments are passed automatically internally based on type of method reference.
The below diagrams will make it clearer.
You can use method reference as below:
Let’s say you want to convert country
to uppercase
before printing it. You can achieve it using anonymous class
and lambda expression
but not with method reference.
You can not use method reference as below:
You can obviously use the stream’s map() method to convert the country
to uppercase
before printing it. I just want to demonstrate when method reference can't be used.
Types of method references
There are four types of method references.
- Reference to static method
- Reference to instance method of object type
- Reference to instance method of existing object
- Reference constructor
Reference to static method
When you have lambda expression which calls to static method, then you can method reference to static method.
Lambda expression syntax(args) -> ClassName.someStaticMethod(args)
can be converted toClassName::someStaticMethod
Let’s see this with the help of example.
Create a class name PowerFunctions
Function is functional interface that takes a single input T and returns a single output R.
We can call calculatePowOf2ForList()
as below:
When you run above program, you will get below output:
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]
If you notice,Function<Integer,Integer> function2 = (num) -> PowerFunctions.power(num);
is of type (args) -> className.someStaticMethod(args)
Here,
PowerFunctions
is className- someStaticMethod is
power
method num
is power method argument.
We are calling a static method power
of class PowerFunctions
in lambda expression, that's why we can use it as method reference.
So instead ofFunction<Integer,Integer> function2 = (num) -> PowerFunctions.power(num);
we can useFunction<Integer,Integer> function3 = PowerFunctions::power;
Here,
- First type parameter of
Function
(Integer) is first parameter of static methodpower()
. - Second type parameter of
Function
(Integer) is return type of static methodpower()
.
Reference to instance method of object type
When you have lambda expression where instance of object is passed and calls to an instance method with/without parameters, then you can use method reference to an instance method with object type.
Lambda expression syntax(obj,args) -> obj.someInstanceMethod(args)
can be converted toobjectType::someInstanceMethod
Let’s see this with the help of example.
BiFunction
is functional interface that takes two arguments and returns single output.
If you notice,BiFunction<String,Integer,String> bf2 = (t,u) -> t.substring(u);
is of type (obj,args) -> obj.someInstanceMethod(args)
Here,
obj
is of type String.- someInstanceMethod is String’s
substring()
method. - args is
beginIndex
forsubstring()
method argument.
So BiFunction<String,Integer,String> bf2 = (t,u) -> t.substring(u);
can be converted to BiFunction<String,Integer,String> bf3 = String::substring;
Here,
- First
BiFunction
parameter type(String) is String object itself. - Second
BiFunction
parameter type(Integer) is argument tosubstring()
method - Third
BiFunction
parameter type(String) is return type ofsubstring()
method
Reference to instance method of existing object
When you have lambda expression where instance of object is used to call an instance method with/without parameters, then you can use method reference to an instance method with an existing object.
Lambda expression syntax(args) -> obj.someInstanceMethod(args)
can be converted toobjectType::someInstanceMethod
Here obj
is defined somewhere else and is not part of argument to lambda expression.
Let’s understand with the help of example.
Create a class named Country.java
.
Create another class MethodReferenceExistingObjectMain.java
Output:
[ name = India population = 20000 ]
[ name = India population = 30000 ]
[ name = India population = 40000 ]
Consumer is functional interface which takes single argument and returns nothing.
If you notice, Consumer popCons2 = (population) -> c.setPopulation(population);
is of type (args) -> obj.someInstanceMethod(args)
Here
- obj is of type Country and declared somewhere else.
- someInstanceMethod is Country’s setPopulation method.
- args is
population
for setPopulation method argument.
So Consumer<Long> popCons2= (population) -> c.setPopulation(population);
can be converted to Consumer<Long> popCons3 = c::setPopulation;
Here,
- The First Consumer parameter type(Long) is argument to setPopulation method.
Reference constructor
When lambda expression is used to create new object with/without parameters, then you can use reference method constructor.
Lambda expression syntax(args) -> new ClassName(args)
can be converted toClassName::new
Let’s see with the help of example.
Here we will convert the list to set using method reference.
Function<List,Set>
is functional interface which will take a list an argument and will return set by calling HashSet constructor public HashSet(Collection<? extends E> c)
Output:
[Sneha, Andy, Rohan]
[Sneha, Andy, Rohan]
[Sneha, Andy, Rohan]
If you notice, Function<List<String>,Set<String>> f2 = (nameList) -> new HashSet<>(nameList);
is of type (args) -> new ClassName(args)
Here
- args is of type
list
- ClassName is
HashSet
So Function<List<String>,Set<String>> f2 = (nameList) -> new HashSet<>(nameList);
can be converted to Function<List<String>,Set<String>> f3= HashSet::new;
Here,
- First
Function
parameter type(List) is argument to HashSet constructor.
Excercise
Let’s practice few exercises based on Method reference.
Excercise:1
Given a list of Integer, you need to find square root of each number in the list and return it as List<Double>.
You need to call Math’s sqrt
static method to find square root of number and use it as method reference
.
Solution:
We can create Function functional interface with method reference and pass it to Stream’s map method.
Output:
[5.0, 6.557438524302, 7.211102550927978, 5.5677643628300215, 9.0]
[5.0, 6.557438524302, 7.211102550927978, 5.5677643628300215, 9.0
Excercise:2
Given a list of String, you need to convert all the String to uppercase
and then return a new List<String>.
Solution:
We can create Function<String,String> functional interface with method reference and pass it to Stream’s map method.
Output:
[ANDREW, MARY, SOHAN, DEBY]
[ANDREW, MARY, SOHAN, DEBY]
If you notice, we are calling String’s toUpperCase()
in lambda expression, hence
we can convert Function<String,String> function1= (name) -> name.toUpperCase();
toFunction<String,String> function2= String::toUpperCase;
.
Excercise:3
Given a list of Color objects, you need to sort them of color’s name and return a sorted list of color names(List<String>
)
Here is the definition of Color class.
Solution:
We can use method reference in map and sorted method as below.
Output:
==========================
Using Lambda expressions
==========================
Blue
Green
Red
White
==========================
Using Method reference
==========================
Blue
Green
Red
White
Conclusion
Method references are special type of lambda expression that simply calls a method. It makes code more readable and concise, but if method references lead to any confusion, then there is no point in using them.
Java 8 tutorial series
- Java 8 tutorial
- Java 8 functional interface
- Java 8 lambda expressions
- Java 8 optional
- Java 8 interview questions
That’s all about method references in java.