java lambda assignment

• Java Tutorial
• What is Java?
• Installing the Java SDK
• Your First Java App
• Java Main Method
• Java Project Overview, Compilation and Execution
• Java Core Concepts
• Java Syntax
• Java Variables
• Java Data Types
• Java Math Operators and Math Class
• Java Arrays
• Java String
• Java Operations
• Java if statements
• Java Ternary Operator
• Java switch Statements
• Java instanceof operator
• Java for Loops
• Java while Loops
• Java Classes
• Java Fields
• Java Methods
• Java Constructors
• Java Packages
• Java Access Modifiers
• Java Inheritance
• Java Nested Classes
• Java Record
• Java Abstract Classes
• Java Interfaces
• Java Interfaces vs. Abstract Classes
• Java Annotations

Java Lambda Expressions

• Java Modules
• Java Scoped Assignment and Scoped Access
• Java Exercises

Matching Lambdas to Interfaces

Interfaces with default and static methods, lambda expressions vs. anonymous interface implementations, lambda type inference, zero parameters, one parameter, multiple parameters, parameter types, var parameter types from java 11, lambda function body, returning a value from a lambda expression, lambdas as objects, local variable capture, instance variable capture, static variable capture, static method references, parameter method reference, instance method references, constructor references.

Java lambda expressions are new in Java 8. Java lambda expressions are Java's first step into functional programming. A Java lambda expression is thus a function which can be created without belonging to any class. A Java lambda expression can be passed around as if it was an object and executed on demand.

Java lambda expressions are commonly used to implement simple event listeners / callbacks, or in functional programming with the Java Streams API . Java Lambda Expressions are also often used in functional programming in Java .

If you prefer video, I have a video version of this tutorial in this Java Lambda Expression YouTube Playlist . Here is the first video in this playlist:

Java Lambdas and the Single Method Interface

Functional programming is very often used to implement event listeners. Event listeners in Java are often defined as Java interfaces with a single method. Here is a fictive single method interface example:

This Java interface defines a single method which is called whenever the state changes (in whatever is being observed).

In Java 7 you would have to implement this interface in order to listen for state changes. Imagine you have a class called StateOwner which can register state event listeners. Here is an example:

In Java 7 you could add an event listener using an anonymous interface implementation, like this:

First a StateOwner instance is created. Then an anonymous implementation of the StateChangeListener interface is added as listener on the StateOwner instance.

In Java 8 you can add an event listener using a Java lambda expression, like this:

The lambda expressions is this part:

The lambda expression is matched against the parameter type of the addStateListener() method's parameter. If the lambda expression matches the parameter type (in this case the StateChangeListener interface) , then the lambda expression is turned into a function that implements the same interface as that parameter.

Java lambda expressions can only be used where the type they are matched against is a single method interface. In the example above, a lambda expression is used as parameter where the parameter type was the StateChangeListener interface. This interface only has a single method. Thus, the lambda expression is matched successfully against that interface.

A single method interface is also sometimes referred to as a functional interface . Matching a Java lambda expression against a functional interface is divided into these steps:

• Does the interface have only one abstract (unimplemented) method?
• Does the parameters of the lambda expression match the parameters of the single method?
• Does the return type of the lambda expression match the return type of the single method?

If the answer is yes to these three questions, then the given lambda expression is matched successfully against the interface.

From Java 8 a Java interface can contain both default methods and static methods. Both default methods and static methods have an implementation defined directly in the interface declaration. This means, that a Java lambda expression can implement interfaces with more than one method - as long as the interface only has a single unimplemented (AKA abstract) method.

In other words, an interface is still a functional interface even if it contains default and static methods, as long as the interface only contains a single unimplemented (abstract) method. Here is a video version of this little section:

The following interface can be implemented with a lambda expression:

Even though this interface contains 3 methods it can be implemented by a lambda expression, because only one of the methods is unimplemented. Here is how the implementation looks:

Even though lambda expressions are close to anonymous interface implementations, there are a few differences that are worth noting.

The major difference is, that an anonymous interface implementation can have state (member variables) whereas a lambda expression cannot. Look at this interface:

This interface can be implemented using an anonymous interface implementation, like this:

This anonymous MyEventConsumer implementation can have its own internal state. Look at this redesign:

Notice how the anonymous MyEventConsumer implementation now has a field named eventCount .

A lambda expression cannot have such fields. A lambda expression is thus said to be stateless.

Before Java 8 you would have to specify what interface to implement, when making anonymous interface implementations. Here is the anonymous interface implementation example from the beginning of this text:

With lambda expressions the type can often be inferred from the surrounding code. For instance, the interface type of the parameter can be inferred from the method declaration of the addStateListener() method (the single method on the StateChangeListener interface). This is called type inference . The compiler infers the type of a parameter by looking elsewhere for the type - in this case the method definition. Here is the example from the beginning of this text, showing that the StateChangeListener interface is not mentioned in the lambda expression:

In the lambda expression the parameter types can often be inferred too. In the example above, the compiler can infer their type from the onStateChange() method declaration. Thus, the type of the parameters oldState and newState are inferred from the method declaration of the onStateChange() method.

Lambda Parameters

Since Java lambda expressions are effectively just methods, lambda expressions can take parameters just like methods. The (oldState, newState) part of the lambda expression shown earlier specifies the parameters the lambda expression takes. These parameters have to match the parameters of the method on the single method interface. In this case, these parameters have to match the parameters of the onStateChange() method of the StateChangeListener interface:

As a minimum the number of parameters in the lambda expression and the method must match.

Second, if you have specified any parameter types in the lambda expression, these types must match too. I haven't shown you how to put types on lambda expression parameters yet (it is shown later in this text), but in many cases you don't need them.

If the method you are matching your lambda expression against takes no parameters, then you can write your lambda expression like this:

Notice how the parentheses have no content in between. That is to signal that the lambda takes no parameters.

If the method you are matching your Java lambda expression against takes one parameter, you can write the lambda expression like this:

Notice the parameter is listed inside the parentheses.

When a lambda expression takes a single parameter, you can also omit the parentheses, like this:

If the method you match your Java lambda expression against takes multiple parameters, the parameters need to be listed inside parentheses. Here is how that looks in Java code:

Only when the method takes a single parameter can the parentheses be omitted.

Specifying parameter types for a lambda expression may sometimes be necessary if the compiler cannot infer the parameter types from the functional interface method the lambda is matching. Don't worry, the compiler will tell you when that is the case. Here is a Java lambda parameter type example:

As you can see, the type ( Car ) of the car parameter is written in front of the parameter name itself, just like you would when declaring a parameter in a method elsewhere, or when making an anonymous implementation of an interface.

From Java 11 you can use the var keyword as parameter type. The var keyword was introduced in Java 10 as local variable type inference . From Java 11 var can also be used for lambda parameter types. Here is an example of using the Java var keyword as parameter types in a lambda expression:

The type of the parameter declared with the var keyword above will be inferred to the type String , because the type declaration of the variable has its generic type set to Function<String, String> , which means that the parameter type and return type of the Function is String .

The body of a lambda expression, and thus the body of the function / method it represents, is specified to the right of the -> in the lambda declaration: Here is an example:

If your lambda expression needs to consist of multiple lines, you can enclose the lambda function body inside the { } bracket which Java also requires when declaring methods elsewhere. Here is an example:

You can return values from Java lambda expressions, just like you can from a method. You just add a return statement to the lambda function body, like this:

In case all your lambda expression is doing is to calculate a return value and return it, you can specify the return value in a shorter way. Instead of this:

You can write:

The compiler then figures out that the expression a1 > a2 is the return value of the lambda expression (hence the name lambda expressions - as expressions return a value of some kind).

A Java lambda expression is essentially an object. You can assign a lambda expression to a variable and pass it around, like you do with any other object. Here is an example:

The first code block shows the interface which the lambda expression implements. The second code block shows the definition of the lambda expression, how the lambda expression is assigned to variable, and finally how the lambda expression is invoked by invoking the interface method it implements.

Variable Capture

A Java lambda expression is capable of accessing variables declared outside the lambda function body under certain circumstances. I have a video version of this section here:

Java lambdas can capture the following types of variables:

• Local variables
• Instance variables
• Static variables

Each of these variable captures will described in the following sections.

A Java lambda can capture the value of a local variable declared outside the lambda body. To illustrate that, first look at this single method interface:

Now, look this lambda expression that implements the MyFactory interface:

Right now this lambda expression is only referencing the parameter value passed to it ( chars ). But we can change that. Here is an updated version that references a String variable declared outside the lambda function body:

As you can see, the lambda body now references the local variable myString which is declared outside the lambda body. This is possible if, and only if, the variable being references is "effectively final", meaning it does not change its value after being assigned. If the myString variable had its value changed later, the compiler would complain about the reference to it from inside the lambda body.

A lambda expression can also capture an instance variable in the object that creates the lambda. Here is an example that shows that:

Notice the reference to this.name inside the lambda body. This captures the name instance variable of the enclosing EventConsumerImpl object. It is even possible to change the value of the instance variable after its capture - and the value will be reflected inside the lambda.

The semantics of this is actually one of the areas where Java lambdas differ from anonymous implementations of interfaces. An anonymous interface implementation can have its own instance variables which are referenced via the this reference. However, an lambda cannot have its own instance variables, so this always points to the enclosing object.

Note: The above design of an event consumer is not particularly elegant. I just made it like that to be able to illustrate instance variable capture.

A Java lambda expression can also capture static variables. This is not surprising, as static variables are reachable from everywhere in a Java application, provided the static variable is accessible (packaged scoped or public).

Here is an example class that creates a lambda which references a static variable from inside the lambda body:

The value of a static variable is also allowed to change after the lambda has captured it.

Again, the above class design is a bit nonsensical. Don't think too much about that. The class primarily serves to show you that a lambda can access static variables.

Method References as Lambdas

In the case where all your lambda expression does is to call another method with the parameters passed to the lambda, the Java lambda implementation provides a shorter way to express the method call. First, here is an example single function interface:

And here is an example of creating a Java lambda instance implementing the MyPrinter interface:

Because the lambda body only consists of a single statement, we can actually omit the enclosing { } brackets. Also, since there is only one parameter for the lambda method, we can omit the enclosing ( ) brackets around the parameter. Here is how the resulting lambda declaration looks:

Since all the lambda body does is forward the string parameter to the System.out.println() method, we can replace the above lambda declaration with a method reference. Here is how a lambda method reference looks:

Notice the double colons :: . These signal to the Java compiler that this is a method reference. The method referenced is what comes after the double colons. Whatever class or object that owns the referenced method comes before the double colons.

You can reference the following types of methods:

• Static method
• Instance method on parameter objects
• Instance method
• Constructor

Each of these types of method references are covered in the following sections.

The easiest methods to reference are static methods. Here is first an example of a single function interface:

And here is a static method that we want to create a method reference to:

And finally here is a Java lambda expression referencing the static method:

Since the parameters of the Finder.find() and MyClass.doFind() methods match, it is possible to create a lambda expression that implements Finder.find() and references the MyClass.doFind() method.

You can also reference a method of one of the parameters to the lambda. Imagine a single function interface that looks like this:

The interface is intended to represent a component able to search s1 for occurrences of s2 . Here is an example of a Java lambda expression that calls String.indexOf() to search:

This is equivalent of this lambda definition:

Notice how the shortcut version references a single method. The Java compiler will attempt to match the referenced method against the first parameter type, using the second parameter type as parameter to the referenced method.

Third, it is also possible to reference an instance method from a lambda definition. First, let us look at a single method interface definition:

This interface represents a component that is capable of "deserializing" a String into an int .

Now look at this StringConverter class:

The convertToInt() method has the same signature as the deserialize() method of the Deserializer deserialize() method. Because of that, we can create an instance of StringConverter and reference its convertToInt() method from a Java lambda expression, like this:

The lambda expression created by the second of the two lines references the convertToInt method of the StringConverter instance created on the first line.

Finally it is possible to reference a constructor of a class. You do that by writing the class name followed by ::new , like this:

Too see how to use a constructor as a lambda expression, look at this interface definition:

The create() method of this interface matches the signature of one of the constructors in the String class. Therefore this constructor can be used as a lambda. Here is an example of how that looks:

This is equivalent to this Java lambda expression:

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Lambda Expressions

One issue with anonymous classes is that if the implementation of your anonymous class is very simple, such as an interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear. In these cases, you're usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. Lambda expressions enable you to do this, to treat functionality as method argument, or code as data.

The previous section, Anonymous Classes , shows you how to implement a base class without giving it a name. Although this is often more concise than a named class, for classes with only one method, even an anonymous class seems a bit excessive and cumbersome. Lambda expressions let you express instances of single-method classes more compactly.

This section covers the following topics:

Approach 1: Create Methods That Search for Members That Match One Characteristic

Approach 2: create more generalized search methods, approach 3: specify search criteria code in a local class, approach 4: specify search criteria code in an anonymous class, approach 5: specify search criteria code with a lambda expression, approach 6: use standard functional interfaces with lambda expressions, approach 7: use lambda expressions throughout your application, approach 8: use generics more extensively, approach 9: use aggregate operations that accept lambda expressions as parameters, lambda expressions in gui applications, syntax of lambda expressions, accessing local variables of the enclosing scope, target types and method arguments, serialization, ideal use case for lambda expressions.

Suppose that you are creating a social networking application. You want to create a feature that enables an administrator to perform any kind of action, such as sending a message, on members of the social networking application that satisfy certain criteria. The following table describes this use case in detail:

Suppose that members of this social networking application are represented by the following Person class:

Suppose that the members of your social networking application are stored in a List<Person> instance.

This section begins with a naive approach to this use case. It improves upon this approach with local and anonymous classes, and then finishes with an efficient and concise approach using lambda expressions. Find the code excerpts described in this section in the example RosterTest .

One simplistic approach is to create several methods; each method searches for members that match one characteristic, such as gender or age. The following method prints members that are older than a specified age:

Note : A List is an ordered Collection . A collection is an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data. For more information about collections, see the Collections trail.

This approach can potentially make your application brittle , which is the likelihood of an application not working because of the introduction of updates (such as newer data types). Suppose that you upgrade your application and change the structure of the Person class such that it contains different member variables; perhaps the class records and measures ages with a different data type or algorithm. You would have to rewrite a lot of your API to accommodate this change. In addition, this approach is unnecessarily restrictive; what if you wanted to print members younger than a certain age, for example?

The following method is more generic than printPersonsOlderThan ; it prints members within a specified range of ages:

What if you want to print members of a specified sex, or a combination of a specified gender and age range? What if you decide to change the Person class and add other attributes such as relationship status or geographical location? Although this method is more generic than printPersonsOlderThan , trying to create a separate method for each possible search query can still lead to brittle code. You can instead separate the code that specifies the criteria for which you want to search in a different class.

The following method prints members that match search criteria that you specify:

This method checks each Person instance contained in the List parameter roster whether it satisfies the search criteria specified in the CheckPerson parameter tester by invoking the method tester.test . If the method tester.test returns a true value, then the method printPersons is invoked on the Person instance.

To specify the search criteria, you implement the CheckPerson interface:

The following class implements the CheckPerson interface by specifying an implementation for the method test . This method filters members that are eligible for Selective Service in the United States: it returns a true value if its Person parameter is male and between the ages of 18 and 25:

To use this class, you create a new instance of it and invoke the printPersons method:

Although this approach is less brittle—you don't have to rewrite methods if you change the structure of the Person —you still have additional code: a new interface and a local class for each search you plan to perform in your application. Because CheckPersonEligibleForSelectiveService implements an interface, you can use an anonymous class instead of a local class and bypass the need to declare a new class for each search.

One of the arguments of the following invocation of the method printPersons is an anonymous class that filters members that are eligible for Selective Service in the United States: those who are male and between the ages of 18 and 25:

This approach reduces the amount of code required because you don't have to create a new class for each search that you want to perform. However, the syntax of anonymous classes is bulky considering that the CheckPerson interface contains only one method. In this case, you can use a lambda expression instead of an anonymous class, as described in the next section.

The CheckPerson interface is a functional interface . A functional interface is any interface that contains only one abstract method . (A functional interface may contain one or more default methods or static methods .) Because a functional interface contains only one abstract method, you can omit the name of that method when you implement it. To do this, instead of using an anonymous class expression, you use a lambda expression , which is highlighted in the following method invocation:

See Syntax of Lambda Expressions for information about how to define lambda expressions.

You can use a standard functional interface in place of the interface CheckPerson , which reduces even further the amount of code required.

Reconsider the CheckPerson interface:

This is a very simple interface. It's a functional interface because it contains only one abstract method. This method takes one parameter and returns a boolean value. The method is so simple that it might not be worth it to define one in your application. Consequently, the JDK defines several standard functional interfaces, which you can find in the package java.util.function .

For example, you can use the Predicate<T> interface in place of CheckPerson . This interface contains the method boolean test(T t) :

The interface Predicate<T> is an example of a generic interface. (For more information about generics, see the Generics (Updated) lesson.) Generic types (such as generic interfaces) specify one or more type parameters within angle brackets ( <> ). This interface contains only one type parameter, T . When you declare or instantiate a generic type with actual type arguments, you have a parameterized type. For example, the parameterized type Predicate<Person> is the following:

This parameterized type contains a method that has the same return type and parameters as CheckPerson.boolean test(Person p) . Consequently, you can use Predicate<T> in place of CheckPerson as the following method demonstrates:

As a result, the following method invocation is the same as when you invoked printPersons in Approach 3: Specify Search Criteria Code in a Local Class to obtain members who are eligible for Selective Service:

This is not the only possible place in this method to use a lambda expression. The following approach suggests other ways to use lambda expressions.

Reconsider the method printPersonsWithPredicate to see where else you could use lambda expressions:

This method checks each Person instance contained in the List parameter roster whether it satisfies the criteria specified in the Predicate parameter tester . If the Person instance does satisfy the criteria specified by tester , the method printPerson is invoked on the Person instance.

Instead of invoking the method printPerson , you can specify a different action to perform on those Person instances that satisfy the criteria specified by tester . You can specify this action with a lambda expression. Suppose you want a lambda expression similar to printPerson , one that takes one argument (an object of type Person ) and returns void. Remember, to use a lambda expression, you need to implement a functional interface. In this case, you need a functional interface that contains an abstract method that can take one argument of type Person and returns void. The Consumer<T> interface contains the method void accept(T t) , which has these characteristics. The following method replaces the invocation p.printPerson() with an instance of Consumer<Person> that invokes the method accept :

As a result, the following method invocation is the same as when you invoked printPersons in Approach 3: Specify Search Criteria Code in a Local Class to obtain members who are eligible for Selective Service. The lambda expression used to print members is highlighted:

What if you want to do more with your members' profiles than printing them out. Suppose that you want to validate the members' profiles or retrieve their contact information? In this case, you need a functional interface that contains an abstract method that returns a value. The Function<T,R> interface contains the method R apply(T t) . The following method retrieves the data specified by the parameter mapper , and then performs an action on it specified by the parameter block :

The following method retrieves the email address from each member contained in roster who is eligible for Selective Service and then prints it:

Reconsider the method processPersonsWithFunction . The following is a generic version of it that accepts, as a parameter, a collection that contains elements of any data type:

To print the e-mail address of members who are eligible for Selective Service, invoke the processElements method as follows:

This method invocation performs the following actions:

• Obtains a source of objects from the collection source . In this example, it obtains a source of Person objects from the collection roster . Notice that the collection roster , which is a collection of type List , is also an object of type Iterable .
• Filters objects that match the Predicate object tester . In this example, the Predicate object is a lambda expression that specifies which members would be eligible for Selective Service.
• Maps each filtered object to a value as specified by the Function object mapper . In this example, the Function object is a lambda expression that returns the e-mail address of a member.
• Performs an action on each mapped object as specified by the Consumer object block . In this example, the Consumer object is a lambda expression that prints a string, which is the e-mail address returned by the Function object.

You can replace each of these actions with an aggregate operation.

The following example uses aggregate operations to print the e-mail addresses of those members contained in the collection roster who are eligible for Selective Service:

The following table maps each of the operations the method processElements performs with the corresponding aggregate operation:

The operations filter , map , and forEach are aggregate operations . Aggregate operations process elements from a stream, not directly from a collection (which is the reason why the first method invoked in this example is stream ). A stream is a sequence of elements. Unlike a collection, it is not a data structure that stores elements. Instead, a stream carries values from a source, such as collection, through a pipeline. A pipeline is a sequence of stream operations, which in this example is filter - map - forEach . In addition, aggregate operations typically accept lambda expressions as parameters, enabling you to customize how they behave.

For a more thorough discussion of aggregate operations, see the Aggregate Operations lesson.

To process events in a graphical user interface (GUI) application, such as keyboard actions, mouse actions, and scroll actions, you typically create event handlers, which usually involves implementing a particular interface. Often, event handler interfaces are functional interfaces; they tend to have only one method.

In the JavaFX example HelloWorld.java (discussed in the previous section Anonymous Classes ), you can replace the highlighted anonymous class with a lambda expression in this statement:

The method invocation btn.setOnAction specifies what happens when you select the button represented by the btn object. This method requires an object of type EventHandler<ActionEvent> . The EventHandler<ActionEvent> interface contains only one method, void handle(T event) . This interface is a functional interface, so you could use the following highlighted lambda expression to replace it:

A lambda expression consists of the following:

A comma-separated list of formal parameters enclosed in parentheses. The CheckPerson.test method contains one parameter, p , which represents an instance of the Person class.

Note : You can omit the data type of the parameters in a lambda expression. In addition, you can omit the parentheses if there is only one parameter. For example, the following lambda expression is also valid:

The arrow token, ->

A body, which consists of a single expression or a statement block. This example uses the following expression:

If you specify a single expression, then the Java runtime evaluates the expression and then returns its value. Alternatively, you can use a return statement:

A return statement is not an expression; in a lambda expression, you must enclose statements in braces ( {} ). However, you do not have to enclose a void method invocation in braces. For example, the following is a valid lambda expression:

Note that a lambda expression looks a lot like a method declaration; you can consider lambda expressions as anonymous methods—methods without a name.

The following example, Calculator , is an example of lambda expressions that take more than one formal parameter:

The method operateBinary performs a mathematical operation on two integer operands. The operation itself is specified by an instance of IntegerMath . The example defines two operations with lambda expressions, addition and subtraction . The example prints the following:

Like local and anonymous classes, lambda expressions can capture variables ; they have the same access to local variables of the enclosing scope. However, unlike local and anonymous classes, lambda expressions do not have any shadowing issues (see Shadowing for more information). Lambda expressions are lexically scoped. This means that they do not inherit any names from a supertype or introduce a new level of scoping. Declarations in a lambda expression are interpreted just as they are in the enclosing environment. The following example, LambdaScopeTest , demonstrates this:

This example generates the following output:

If you substitute the parameter x in place of y in the declaration of the lambda expression myConsumer , then the compiler generates an error:

The compiler generates the error "Lambda expression's parameter x cannot redeclare another local variable defined in an enclosing scope" because the lambda expression does not introduce a new level of scoping. Consequently, you can directly access fields, methods, and local variables of the enclosing scope. For example, the lambda expression directly accesses the parameter x of the method methodInFirstLevel . To access variables in the enclosing class, use the keyword this . In this example, this.x refers to the member variable FirstLevel.x .

However, like local and anonymous classes, a lambda expression can only access local variables and parameters of the enclosing block that are final or effectively final. In this example, the variable z is effectively final; its value is never changed after it's initialized. However, suppose that you add the following assignment statement in the the lambda expression myConsumer :

Because of this assignment statement, the variable z is not effectively final anymore. As a result, the Java compiler generates an error message similar to "Local variable z defined in an enclosing scope must be final or effectively final".

Target Typing

How do you determine the type of a lambda expression? Recall the lambda expression that selected members who are male and between the ages 18 and 25 years:

This lambda expression was used in the following two methods:

public static void printPersons(List<Person> roster, CheckPerson tester) in Approach 3: Specify Search Criteria Code in a Local Class

public void printPersonsWithPredicate(List<Person> roster, Predicate<Person> tester) in Approach 6: Use Standard Functional Interfaces with Lambda Expressions

When the Java runtime invokes the method printPersons , it's expecting a data type of CheckPerson , so the lambda expression is of this type. However, when the Java runtime invokes the method printPersonsWithPredicate , it's expecting a data type of Predicate<Person> , so the lambda expression is of this type. The data type that these methods expect is called the target type . To determine the type of a lambda expression, the Java compiler uses the target type of the context or situation in which the lambda expression was found. It follows that you can only use lambda expressions in situations in which the Java compiler can determine a target type:

Variable declarations

Assignments

Return statements

Array initializers

Method or constructor arguments

Lambda expression bodies

Conditional expressions, ?:

Cast expressions

For method arguments, the Java compiler determines the target type with two other language features: overload resolution and type argument inference.

Consider the following two functional interfaces ( java.lang.Runnable and java.util.concurrent.Callable<V> ):

The method Runnable.run does not return a value, whereas Callable<V>.call does.

Suppose that you have overloaded the method invoke as follows (see Defining Methods for more information about overloading methods):

Which method will be invoked in the following statement?

The method invoke(Callable<T>) will be invoked because that method returns a value; the method invoke(Runnable) does not. In this case, the type of the lambda expression () -> "done" is Callable<T> .

You can serialize a lambda expression if its target type and its captured arguments are serializable. However, like inner classes , the serialization of lambda expressions is strongly discouraged.

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

Java Tutorial

Java methods, java classes, java file handling, java how to, java reference, java examples, java lambda expressions.

Lambda Expressions were added in Java 8.

A lambda expression is a short block of code which takes in parameters and returns a value. Lambda expressions are similar to methods, but they do not need a name and they can be implemented right in the body of a method.

The simplest lambda expression contains a single parameter and an expression:

To use more than one parameter, wrap them in parentheses:

Expressions are limited. They have to immediately return a value, and they cannot contain variables, assignments or statements such as if or for . In order to do more complex operations, a code block can be used with curly braces. If the lambda expression needs to return a value, then the code block should have a return statement.

Advertisement

Using Lambda Expressions

Lambda expressions are usually passed as parameters to a function:

Use a lambda expression in the ArrayList 's forEach() method to print every item in the list:

Try it Yourself »

Lambda expressions can be stored in variables if the variable's type is an interface which has only one method. The lambda expression should have the same number of parameters and the same return type as that method. Java has many of these kinds of interfaces built in, such as the Consumer interface (found in the java.util package) used by lists.

Use Java's Consumer interface to store a lambda expression in a variable:

To use a lambda expression in a method, the method should have a parameter with a single-method interface as its type. Calling the interface's method will run the lambda expression:

Create a method which takes a lambda expression as a parameter:

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot

• Explore Our Geeks Community
• Java 8 Features - Complete Tutorial

Lambda Expressions

• Lambda Expression in Java
• Java - Lambda Expressions Parameters
• Java Lambda Expression with Collections
• Java - Lambda Expression Variable Capturing with Examples
• How to Create Thread using Lambda Expressions in Java?
• Serialization of Lambda Expression in Java
• Block Lambda Expressions in Java
• Match Lambdas to Interfaces in Java
• Converting ArrayList to HashMap in Java 8 using a Lambda Expression
• Check if a String Contains Only Alphabets in Java Using Lambda Expression
• Remove elements from a List that satisfy given predicate in Java

Functional Interfaces

• Functional Interfaces in Java
• Java 8 | Consumer Interface in Java with Examples
• Java 8 | BiConsumer Interface in Java with Examples
• Java 8 Predicate with Examples
• Function Interface in Java with Examples
• Supplier Interface in Java with Examples

Method Reference

• Method References in Java with examples
• Converting ArrayList to HashMap using Method Reference in Java 8
• Java 8 Stream Tutorial
• Difference Between Streams and Collections in Java
• Implement Filter Function using Reduce in Java 8 Streams
• Java Stream API – Filters
• Parallel vs Sequential Stream in Java
• Functional Programming in Java 8+ using the Stream API with Example
• Intermediate Methods of Stream in Java
• Difference Between map() And flatMap() In Java Stream
• Array to Stream in Java
• 10 Ways to Create a Stream in Java

Java Stream Programs

• Program to convert a Map to a Stream in Java
• Program to convert Boxed Array to Stream in Java
• Program to convert Primitive Array to Stream in Java
• Program to convert a Set to Stream in Java using Generics
• Program to Convert List to Stream in Java
• Program to Convert Stream to an Array in Java
• How to get Slice of a Stream in Java
• Flattening Nested Collections in Java
• How to convert a Stream into a Map in Java
• Find the first element of a Stream in Java

Java Stream Methods

• Stream forEach() method in Java with examples
• Stream forEachOrdered() method in Java with examples
• foreach() loop vs Stream foreach() vs Parallel Stream foreach()
• Stream of() method in Java
• Java Stream findAny() with examples
• Stream anyMatch() in Java with examples
• Stream allMatch() in Java with examples
• Stream filter() in Java with examples
• Stream sorted (Comparator comparator) method in Java
• Stream sorted() in Java

Comparable and Comparator

• Comparable vs Comparator in Java
• Comparator Interface in Java with Examples
• Why to Use Comparator Interface Rather than Comparable Interface in Java?
• Sort an Array of Triplet using Java Comparable and Comparator
• Java Program to Sort LinkedList using Comparable
• How to Sort HashSet Elements using Comparable Interface in Java?
• Sort LinkedHashMap by Values using Comparable Interface in Java
• Sort LinkedHashMap by Keys using Comparable Interface in Java
• How to Sort LinkedHashSet Elements using Comparable Interface in Java?

Optional Class

• Java 8 Optional Class
• Optional ofNullable() method in Java with examples
• Optional orElse() method in Java with examples
• Optional ifPresentOrElse() method in Java with examples
• Optional orElseGet() method in Java with examples
• Optional filter() method in Java with examples
• Optional empty() method in Java with examples
• Optional hashCode() method in Java with examples
• Optional toString() method in Java with examples
• Optional equals() method in Java with Examples

Date/Time API

• New Date-Time API in Java 8
• java.time.LocalDate Class in Java
• java.time.LocalTime Class in Java
• java.time.LocalDateTime Class in Java
• java.time.MonthDay Class in Java
• java.time.OffsetTime Class in Java
• java.time.OffsetDateTime Class in Java
• java.time.Clock Class in Java
• java.time.ZonedDateTime Class in Java
• java.time.ZoneId Class in Java

Java – Lambda Expression Variable Capturing with Examples

Variable defined by the enclosing scope of a lambda expression are accessible within the lambda expression. For example,  a lambda expression can use an instance or static variable defined by its enclosing class. A lambda expression also has access to  (both explicitly and implicitly), which refers to the invoking instance of the lambda expression’s enclosing class. Thus, a lambda expression can obtain or set the value of an intrinsic or static variable and call a method define by its enclosing class.

  Lambda expression in java Using a local variable is as stated.

However, when a lambda expression uses a local variable from its enclosing scope, a special situation is created that is referred to as a variable capture. In this case, a lambda expression may only use local variables that are effectively final . An effectively final variable is one whose value does not change after it is first assigned. There is no need to explicitly declare such a variable as final, although doing so would not be an error.

It is important to understand that a local variable of the enclosing scope cannot be modified by the lambda expression. Doing so would remove its effectively final status, thus rendering it illegal for capture.

There are certain keypoints to be remembered, which are as follows: 

• Any local variable, formal parameter, or exception parameter used but not declared in a lambda expression must either be declared final or be effectively final , or a compile-time error occurs where the use is attempted.
• Any local variable used but not declared in a lambda body must be definitely assigned before the lambda body, or a compile-time error occurs.
• Similar rules on variable use apply in the body of an inner class . The restriction to effectively final variables prohibits access to dynamically-changing local variables, whose capture would likely introduce concurrency problems. Compared to the final restriction, it reduces the clerical burden on programmers.
• The restriction to effectively final variables includes standard loop variables, but not enhanced-for loop variables, which are treated as distinct for each iteration of the loop.

The following program illustrates the difference between effectively final and mutable local variables:

Output explanation: 

As the comments indicate, number is effectively final and can, therefore, be used inside myLambda. However, if number were to be modified, either inside the lambda or outside of it, number would lose its effective final status. This would cause an error, and the program would not compile. 

Note: It is important to emphasize that a lambda expression can use and modify an instance variable from its invoking class. It just can’t use a local variable of its enclosing scope unless that variable is effectively final.

Please Login to comment...

• java-lambda

Please write us at [email protected] to report any issue with the above content

Improve your Coding Skills with Practice

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java introduction.

• Java Hello World
• Java JVM, JRE and JDK
• Java Variables and Literals
• Java Data Types
• Java Operators
• Java Input and Output
• Java Expressions & Blocks
• Java Comment

Java Flow Control

• Java if...else
• Java switch Statement
• Java for Loop
• Java for-each Loop
• Java while Loop
• Java break Statement
• Java continue Statement
• Java Arrays
• Multidimensional Array
• Java Copy Array

Java OOP (I)

• Java Class and Objects
• Java Methods
• Java Method Overloading
• Java Constructor
• Java Strings
• Java Access Modifiers
• Java this keyword
• Java final keyword
• Java Recursion
• Java instanceof Operator

Java OOP (II)

• Java Inheritance
• Java Method Overriding
• Java super Keyword
• Abstract Class & Method
• Java Interfaces
• Java Polymorphism
• Java Encapsulation

Java OOP (III)

• Nested & Inner Class
• Java Static Class
• Java Anonymous Class
• Java Singleton
• Java enum Class
• Java enum Constructor
• Java enum String
• Java Reflection
• Java Exception Handling
• Java Exceptions
• Java try...catch
• Java throw and throws
• Java catch Multiple Exceptions
• Java try-with-resources
• Java Annotations
• Java Annotation Types
• Java Logging
• Java Assertions
• Java Collections Framework
• Java Collection Interface
• Java List Interface
• Java ArrayList
• Java Vector
• Java Queue Interface
• Java PriorityQueue
• Java Deque Interface
• Java LinkedList
• Java ArrayDeque
• Java BlockingQueue Interface
• Java ArrayBlockingQueue
• Java LinkedBlockingQueue
• Java Map Interface
• Java HashMap
• Java LinkedHashMap
• Java WeakHashMap
• Java EnumMap
• Java SortedMap Interface
• Java NavigableMap Interface
• Java TreeMap
• Java ConcurrentMap Interface
• Java ConcurrentHashMap
• Java Set Interface
• Java HashSet
• Java EnumSet
• Java LinkedhashSet
• Java SortedSet Interface
• Java NavigableSet Interface
• Java TreeSet
• Java Algorithms
• Java Iterator
• Java ListIterator
• Java I/O Streams
• Java InputStream
• Java OutputStream
• Java FileInputStream
• Java FileOutputStream
• Java ByteArrayInputStream
• Java ByteArrayOutputStream
• Java ObjectInputStream
• Java ObjectOutputStream
• Java BufferedInputStream
• Java BufferedOutputStream
• Java PrintStream

Java Reader/Writer

• Java Reader
• Java Writer
• Java InputStreamReader
• Java OutputStreamWriter
• Java FileReader
• Java FileWriter
• Java BufferedReader
• Java BufferedWriter
• Java StringReader
• Java StringWriter
• Java PrintWriter

Additional Topics

• Java Scanner Class
• Java Type Casting
• Java autoboxing and unboxing
• Java Lambda Expression
• Java Generics
• Java File Class
• Java Wrapper Class
• Java Command Line Arguments

Java Tutorials

Java Iterator Interface

Java HashMap forEach()

Java ArrayList forEach()

Java Interface

• Java enum Inheritance and Interface

Java Lambda Expressions

The lambda expression was introduced first time in Java 8. Its main objective to increase the expressive power of the language.

But, before getting into lambdas, we first need to understand functional interfaces.

• What is Functional Interface?

If a Java interface contains one and only one abstract method then it is termed as functional interface. This only one method specifies the intended purpose of the interface.

For example, the Runnable interface from package java.lang ; is a functional interface because it constitutes only one method i.e. run() .

Example 1: Define a Functional Interface in java

In the above example, the interface MyInterface has only one abstract method getValue(). Hence, it is a functional interface.

Here, we have used the annotation @FunctionalInterface . The annotation forces the Java compiler to indicate that the interface is a functional interface. Hence, does not allow to have more than one abstract method. However, it is not compulsory though.

In Java 7, functional interfaces were considered as Single Abstract Method s or SAM type. SAMs were commonly implemented with Anonymous Classes in Java 7.

Example 2: Implement SAM with anonymous classes in java

Here, we can pass an anonymous class to a method. This helps to write programs with fewer codes in Java 7. However, the syntax was still difficult and a lot of extra lines of code were required.

Java 8 extended the power of a SAMs by going a step further. Since we know that a functional interface has just one method, there should be no need to define the name of that method when passing it as an argument. Lambda expression allows us to do exactly that.

Introduction to lambda expressions

Lambda expression is, essentially, an anonymous or unnamed method. The lambda expression does not execute on its own. Instead, it is used to implement a method defined by a functional interface.

How to define lambda expression in Java?

Here is how we can define lambda expression in Java.

The new operator ( -> ) used is known as an arrow operator or a lambda operator. The syntax might not be clear at the moment. Let's explore some examples,

Suppose, we have a method like this:

We can write this method using lambda expression as:

Here, the method does not have any parameters. Hence, the left side of the operator includes an empty parameter. The right side is the lambda body that specifies the action of the lambda expression. In this case, it returns the value 3.1415.

• Types of Lambda Body

In Java, the lambda body is of two types.

1. A body with a single expression

This type of lambda body is known as the expression body.

2. A body that consists of a block of code.

This type of the lambda body is known as a block body. The block body allows the lambda body to include multiple statements. These statements are enclosed inside the braces and you have to add a semi-colon after the braces.

Note : For the block body, you can have a return statement if the body returns a value. However, the expression body does not require a return statement.

• Example 3: Lambda Expression

Let's write a Java program that returns the value of Pi using the lambda expression.

As mentioned earlier, a lambda expression is not executed on its own. Rather, it forms the implementation of the abstract method defined by the functional interface.

So, we need to define a functional interface first.

In the above example,

• We have created a functional interface named MyInterface . It contains a single abstract method named getPiValue()
• Inside the Main class, we have declared a reference to MyInterface . Note that we can declare a reference of an interface but we cannot instantiate an interface. That is,   // it will throw an error MyInterface ref = new myInterface(); // it is valid MyInterface ref;
• We then assigned a lambda expression to the reference. ref = () -> 3.1415;
• Finally, we call the method getPiValue() using the reference interface. When   System.out.println("Value of Pi = " + ref.getPiValue());
• Lambda Expressions with parameters

Till now we have created lambda expressions without any parameters. However, similar to methods, lambda expressions can also have parameters. For example,

Here, the variable n inside the parenthesis is a parameter passed to the lambda expression. The lambda body takes the parameter and checks if it is even or odd.

Example 4: Using lambda expression with parameters

• Generic Functional Interface

Till now we have used the functional interface that accepts only one type of value. For example,

The above functional interface only accepts String and returns String . However, we can make the functional interface generic, so that any data type is accepted. If you are not sure about generics, visit Java Generics .

Example 5: Generic Functional Interface and Lambda Expressions

In the above example, we have created a generic functional interface named GenericInterface . It contains a generic method named func() .

Here, inside the Main class,

• GenericInterface<String> reverse - creates a reference to the interface. The interface now operates on String type of data.
• GenericInterface<Integer> factorial - creates a reference to the interface. The interface, in this case, operates on the Integer type of data.
• Lambda Expression and Stream API

The new java.util.stream package has been added to JDK8, which allows Java developers to perform operations like search, filter, map, reduce, or manipulate collections like Lists .

For example, we have a stream of data (in our case, a List of String ) where each string is a combination of the country name and place of the country. Now, we can process this stream of data and retrieve only the places from Nepal.

For this, we can perform bulk operations in the stream by the combination of Stream API and Lambda expression.

Example 6: Demonstration of using lambdas with the Stream API

In the above example, notice the statement

Here, we are using the methods like filter() , map() and forEach() of the Stream API. These methods can take a lambda expression as input.

We can also define our own expressions based on the syntax we learned above. This allows us to reduce the lines of code drastically as we saw in the above example.

Table of Contents

• Introduction to lambda expression

Sorry about that.

Related Tutorials

Java Tutorial

Java Library

Functional Programming with Java Lambda

November 11, 2021.

Java is an object-oriented programming language. It promotes the encapsulation of all variables and methods of the class. That is, code blocks before Java version 8 are written by binding classes with variables, methods, and objects.

The process of passing a behavior to methods takes extra work and load. This is because we are passing a class with another attribute. In Java 8, Lambda was introduced to represent the functional interface of Java. This means that the Lambda expression is the expression of a functional interface.

The introduction of functional programming was to implement behavior code. This code makes it easier to create a function that performs a specific task. Also, this code does not belong to any class thus it is treated as a value.

In this article, the reader will understand Java’s functional programming and learn how to assign lambdas to an interface. We will work with lambda expressions using a different number of parameters.

The reader will be able to convert the object or a class’s method to lambdas function with less code. The reader will also understand the importance of using functional programming.

Prerequisites

To follow along with this tutorial, the reader should have:

• A basic knowledge of Java.
• Java installed.
• Any Java IDE of their choice.
• An understanding of class’s and static methods.

Passing a function as a value

Let us assign a value to our variable:

The variable name takes a single string value of foo and a variable pi takes a single double value of 3.14 . The question is, can a block of code be assigned as a value to a variable name without creating an instance of the class?

This is not possible in Java, as only an instance of an object can be assigned to a variable. Let us imagine a block code is assigned to a variable.

With Java functional programming, assigning a block of code to a variable is possible. Let us consider the code above with lambdas expressions.

To represent the code above in lambdas expression, a lot of elements in the block of code can be removed.

From our code above, we can see that the access modifier and return type are removed. This is because they are not required in the expression.

The lambda expression has a very simple, unique, and flexible syntax. This syntax also follows the normal syntax of the assignment of a value to a variable in Java. That is, assigning a variable with a data type and the expression as a value.

Java is a strongly typed programming language because every variable must be declared with a data type. The method of assigning a variable name to a lambda expression must also have a data type of the class’s interface.

The syntax of the value which is the expression consists of three parts which are:

• Expression body - This can either be a single expression or a block of code. If the body of the function contains a single expression, the braces are not required which means it is optional.
• Parameter - These are functional methods that match with the signature of a function declared in the interface. Defining the information kind of parameter is discretionary but the number of parameters must coordinate with the signature declared in the interface.
• The Lambda operator -> - This separates the input parameters on the left side from the lambda body on the right side.

To use Lambda expressions, you can create your functional interface or use Java’s already defined interface. The interface used must match the signature of the function you want to use. An interface with a single abstract method is called a @FunctionalInterface .

The first line of the code above is an interface with the name Hello . The interface declares an abstract method called sayHello . The method takes one parameter called greet which is of the data type string and thus its return type will be a string.

The fourth line creates a new class called LambdaAlgorithmTest which contains the main method. The method declares a function called hello with the type Hello interface.

We also have another method that takes one parameter called message with two variables str1 and str2 which are both of the type string . The first variable str1 takes a value Welcome , the second variable str2 concatenates str1 , and the parameter message . The function returns the variable str2 .

Working with different Lambda parameter

Lambda example that takes no parameter.

The first line of the above code, @FunctionalInterface is an annotation that ensures the functional interface does not have more than one abstract method. The second line declares an interface with the name MyFunctionalInterface .

The interface declares a method called sayHello , which takes no parameters. The method will return the typed string.

The third line creates a new class called Example which contains the main method. The method declares a function msg with type MyFunctionalInterface interface. The result of the function will print Hello .

Lambda example with a single parameter

The first line of the above code, @FunctionalInterface is a Java annotation that ensures the functional interface does not have more than one abstract method. The second line is an interface with the name MyFunctionalInterface . The interface declares an abstract method called increaseByFive , which takes one parameter. The method will return the type int.

The third line creates a new class called LambdaSingleParam . The class contains the main method. The main method declares a function foo with the type MyFunctionalInterface interface. The result of the function will print 27 .

Lambda example with many parameters

The first line of the above code, interface StringConcat declares a new interface StringConcat . The interface declares an abstract method called strConcat . The method takes two-parameter. The method will return the typed string.

The third line creates a new class called LambdaMultipleParameter . The class contains the main method which serves as the entry point of the code. The method declares function str with type StringConcat interface.

The last line of code print concatenation of string Result with the result of the method call str.strConcat("Hello ", "World") . The result of the function will print Result: Hello World .

Lambda stream pipeline

Streams are objects of classes that implement the interface stream . The stream is either from one of the specific stream interfaces for preparing collections of primitive data values. Stream enables you to act on the collection of elements with lambda.

Lambda Stream pipeline is a sequence of processing steps from the data source (from collections). The pipeline performs two main operations which is an intermediate or terminal operation. The operations form a chain method.

Intermediate and terminal operation

An intermediate operation is an activity that plays out a particular task on a stream element and the result of the task forms a new stream. Intermediate operations are also called Lazy operations which implies that the operation is not performed until a terminal operation is called.

The intermediate operation

A terminal operation starts the processing of intermediate operations performed on a stream and produces a result. Terminal operations are known as eager operations. Eager operations are operations that carry out the requested tasks whenever called.

Example of stream operation

The first line of the code above declares the main method. The main method serves as the entry point of the code to the Java interpreter. The second line of the code declares an ArrayList myList that takes an array value.

• Arrays.asList() converts the array to a list.
• myList.stream() converts the list to a stream.
• filter(s -> s.startsWith("c")) filters the element of the list that start with c .
• map(String::toUpperCase) converts the elements that meet the filter condition to capital letters.
• The sorted() method returns sorted elements in ascending order by default.
• The forEach(System.out::println) loops through all the elements in the stream and prints the elements that meet all requirements specified in the pipeline.

The benefits of lambda in Java

• Lambda expressions improve code readability and do not require interpretation.
• Lambdas allow you to write concise code.
• It encourages the use of functional programming.
• It simplifies variable scope and encourages code reusability.
• Lambdas allow you to use parallel processing.

In this article, we looked at the concept of functional programming in Java. We explained how a function can be used as a value. We also looked at how to create a functional program and how to work with different parameters in lambda.

Lastly, we explained the concept of a stream pipeline by giving insight into the intermediate and terminal operations. The article also touches on the benefit of lambda functional programming.

The stream pipeline concept explained in this article is an introduction. To learn more about stream, check out Java version 16 documentation on stream .

• Java version 16 documentation on stream
• Theserveside blog
• Stackity stream guide
• Java 16 documentation on function API
• Java - How to Program 10th Ed - Early Objects Version by Pual Deitel and Harvey Deitel
• Introduction to Java Programming, Comprehensive Version by Y. Daniel Liang of Armstrong Atlantic State University

Peer Review Contributions by: Dawe Daniel

Similar Articles

How to Create a Basic Browser GraphiQL Tool using React.js, Node.js and MongoDB

Stir Framework in Action in a Spring Web App

How to Create a Reusable React Form component