Just Learn Code

Efficient Method Passing: Lambda Functions & Method References in Java 8

Passing Method as a Parameter using Lambda Functions and Method References in Java

Java programming language keeps evolving, and with each new version comes new features that make the code more efficient. With the release of Java 8, developers got access to a new feature called Lambda functions.

Lambda functions can simplify code, improve its efficiency, and offer flexible ways of passing a method as a parameter.

Lambda Functions as a way to pass method in Java 8

A Lambda function is a concise way to represent anonymous functions. It is an implementation of a functional interface just like an anonymous class, but written in a shorter syntax.

The primary objective of a Lambda function is to set a code block as a parameter to a functional interface. Function interfaces can replace one method interfaces such as Runnable, Callable, and Comparator.

Using Lambda functions, developers can pass a method as an argument to a constructor, a method, and also as a return. Lambda functions consist of three parts:


Parameters: The input parameters are enclosed in parentheses and can be empty

or multiple. 2.

Arrow operator: It is a new feature in the Java programming language and useful in Lambda functions.


Body: It represents the executed block of code

or statements enclosed in curly braces. Example of Lambda function:


(parameter(s)) -> expression


(parameter(s)) -> { statements }


Lambda functions are supported by the Java compiler that ensures the compatibility with older versions of Java. The key benefit of Lambda functions is that they allow concise code and avoid the ceremony that comes with anonymous classes.

Passing Lambda Function as a parameter to built-in and custom methods

The primary advantage of Lambda functions is their flexibility in passing methods as parameters. They can replace heavy anonymous classes that are used to implement interfaces.

Lambda functions support method references and anonymous functions, enabling developers to pass multiple methods in as parameters. When passing a Lambda function in as a parameter, the functional interface receiving it is evaluated inclusively with the Lambda function’s result.

The functional interface’s evaluation is done at runtime upon reaching the Lambda function expression.

Custom Method Implementation

Functional interfaces are used extensively with Lambda functions because they rely on a single abstract method within a class, which can then be easily called by the Lambda function. Functional interfaces are easy to represent as method references.

Here is an example of a functional interface f

or a custom method:


interface CustomMethod {

void customMessage(String message);



The method reference can be used to pass a custom message as an argument of a Lambda function:


CustomMethod myMessage = System.out::println;

myMessage.customMessage(“Lambda function as a Parameter!”);


The output will be “Lambda function as a Parameter!” Because the argument message is passed through the Lambda function method reference, System.out::println.

Iterating through ArrayList using Lambda Functions

The Iterable interface is used to allow data structures to expose their internal collections through an external list method. Developers can use the iterable interface with Lambda functions to interate through an ArrayList.

Here is an example of how to iterate through an ArrayList using Lambda functions:


ArrayList myArray = new ArrayList<>();






The forEach() method evokes the Java.util.function.Consumer interface and provides each element of the array as an argument to the Lambda function, which in this case is System.out::println.


Lambda functions have provided flexibility and simplicity in the Java programming language. They have simplified the way of writing codes, and method passing as a parameter has become more concise.

It has made identifying anonymous classes f

or method implementations more comfortable. The Iterable interface also eases the process of interating through ArrayList, and the forEach() method coupled with Lambda functions makes iterating tasks simple.

In conclusion, Lambda functions provide an efficient way to pass a method in Java, resulting in concise code, better readability, and flexibility. Developers can make use of implemented custom methods with functional interfaces and iterate through ArrayList using Lambda functions.

3) Example Code: Passing Lambda Function as a Parameter to a Custom Method

Lambda functions and functional interfaces simplify the process of passing methods as parameters to built-in and custom methods. A custom interface and method can implement this feature to make them more-functional and concise.

Doable Interface

A doable interface represents a functional interface in which the abstract method returns nothing and does not take any arguments. It is often used as an interface f

or a command method that does a single action without being provided with any arguments.

Here is an example of how to create a doable Interface:


interface Doable {

void doSomething();



Custom Method Using Lambda Function as Parameter

In using Lambda functions as a parameter f

or a custom method implementation, the doSomething() method in the Doable interface accepts a Lambda function as its parameter. “`java

public static void methodImplement(Doable doable) {




The method above receives the doable interface, allowing it to implement a single method that returns nothing and takes no arguments.

This interface is simple and practical f

or passing Lambda functions into its doSomething() method. Here is an example of how to pass a Lambda function as a parameter using the custom method implementation:


methodImplement( () -> {

System.out.println(“This is my Lambda Function parameter!”);

} );


The output displays “This is my Lambda Function parameter!” because the Lambda function is defined in the doSomething() method in the Doable interface when methodImplement() is called.

4) Example Code: Using Method Reference to Pass Method as Parameter

Lambda functions and method references allow developers to pass methods as parameters to built-in and custom methods in Java 8. Method reference is another mechanism that simplifies the process of passing methods as parameters.

Method ReferenceA method reference is a concise and expressive way f

or implementing methods using Lambda functions. It replaces the extra set of curly braces used in Lambda functions with a direct method reference.

In Java 8, there are different kinds of method references. They allow you to reference the method of a specific class and refer to constructors.

Here is an example of how to use a method reference:


public void show() {

System.out.println(“This is an example of a method reference”);




Thread t = new Thread(this::show);



In the code above, show() is assigned to a Thread object construct

or using a method reference. This shows how to pass method reference as a parameter to a Thread() constructor.

The output displays “This is an example of a method reference” because the show() method is called upon execution of the Thread() constructor, which then calls the run() method.


Lambda functions and method references provide a simplified and expressive way of passing methods as parameters to custom and built-in methods in Java 8. A doable interface can be created to allow implementation of a single method that returns nothing and does not take any arguments.

The method reference is also useful in replacing the use of anonymous classes to reference methods. Using these features can help to achieve more concise and readable code.

In conclusion, Lambda functions and Method references in Java 8 provide an efficient means of passing methods as parameters to custom and built-in methods. A doable interface allows f

or simplicity and flexibility while method references make it easy to reference methods in a concise and expressive manner.

The ability to pass methods as parameters makes it possible to achieve more concise and readable code, avoiding heavy anonymous classes. Programmers can take advantage of these features to simplify code and improve its efficiency, leaving more room f

or innovation.

It is essential to understand and make use of these functionalities to write efficient Java code.

Popular Posts