java lambda assignment

Learn Java practically and Get Certified .

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.

Introduction to lambda expression

Sorry about that.

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 :

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

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.

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

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

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:

Java Lambda Expressions Functional Interfaces Tutorial

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:

Watch & Listen
Oracle University

Next in the Series: Using Lambdas Expressions in Your Application

Writing Your First Lambda Expression

In 2014, Java SE 8 saw the introduction of the concept of lambda expressions. If you remember the days before Java SE 8 was released, then you probably remember the anonymous classes concept. And maybe you have heard that lambda expressions are another, simpler way of writing instances of anonymous classes, in some precise cases.

If you do not remember those days, then you may have heard or read about anonymous classes, and are probably afraid of this obscure syntax.

Well, the good news is: you do not need to go through anonymous classes to understand how to write a lambda expression. Moreover, in many cases, thanks to the addition of lambdas to the Java language, you do not need anonymous classes anymore.

Writing a lambda expression breaks down to understanding three steps:

identifying the type of the lambda expression you want to write
finding the right method to implement
implementing this method.

This is really all there is to it. Let us see these three steps in detail.

Identifying the Type of a Lambda Expression

Everything has a type in the Java language, and this type is known at compile time. So it is always possible to find the type of a lambda expression. It may be the type of a variable, of a field, of a method parameter, or the returned type of a method.

There is a restriction on the type of a lambda expression: it has to be a functional interface. So an anonymous class that does not implement a functional interface cannot be written as a lambda expression.

The complete definition of what functional interfaces are is a little complex. All you need to know at this point is that a functional interface is an interface that has only one abstract method.

You should be aware that, starting with Java SE 8, concrete methods are allowed in interfaces. They can be instance methods, in that case, they are called default methods , and they can be static methods. These methods do not count, since they are not abstract methods.

Do I need to add the annotation @FunctionalInterface on an interface to make it functional? No you don't. This annotation is here to help you to make sure that your interface is indeed functional. If you put this annotation on a type that is not a functional interface, then the compiler will raise an error.

Examples of Functional Interfaces

Let us see some examples taken from the JDK API. We have just removed the comments from the source code.

The Runnable interface is indeed functional, because it has only one abstract method. The @FunctionalInterface annotation has been added as a helper, but it is not needed.

The Consumer<T> interface is also functional: it has one abstract method and one default, concrete method that does not count. Once again, the @FunctionalInterface annotation is not needed.

The Predicate<T> interface is a little more complex, but it is still a functional interface:

it has one abstract method
it has three default methods that do not count
and it has two static methods that do not count neither.

Finding the Right Method to Implement

At this point you have identified the type of the lambda expression you need to write, and the good news is: you have done the hardest part: the rest is very mechanical and easier to do.

A lambda expression is an implementation of the only abstract method in this functional interface. So finding the right method to implement is just a matter of finding this method.

You can take a minute to look for it in the three examples of the previous paragraph.

For the Runnable interface it is:

For the Predicate interface it is:

And for the Consumer<T> interface it is:

Implementing the Right Method with a Lambda Expression

Writing a first lambda expression that implements predicate<string>.

Now for the last part: writing the lambda itself. What you need to understand is that the lambda expression you are writing is an implementation of the abstract method you found. Using the lambda expression syntax, you can nicely inline this implementation in your code.

This syntax is made of three elements:

a block of parameters;
a little piece of ASCII art depicting an arrow: -> . Note that Java uses meager arrows ( -> ) and not fat arrows ( => );
a block of code which is the body of the method.

Let us see examples of this. Suppose you need an instance of a Predicate that returns true for strings of characters that have exactly 3 characters.

The type of your lambda expression is Predicate
The method you need to implement is boolean test(String s)

Then you write the block of parameters, which is simple copy / paste of the signature of the method: (String s) .

You then add a meager arrow: -> .

And the body of the method. Your result should look like this:

Simplifying the Syntax

This syntax can then be simplified, thanks to the compiler that can guess many things so that you do not need to write them.

First, the compiler knows that you are implementing the abstract method of the Predicate interface, and it knows that this method takes a String as a argument. So (String s) can be simplified to (s) . In that case, where there is only one argument, you can even go one step further by removing the parentheses. The block of arguments then becomes s . You should keep the parentheses if you have more than one argument, or no argument.

Second, there is just one line of code in the body of the method. In that case you do not need the curly braces nor the return keyword.

So the final syntax is in fact the following:

And this leads us to the first good practice: keep your lambdas short, so that they are just one line of simple, readable code.

Implementing a Consumer<String>

At some point, people may be tempted to take shortcuts. You will hear developers saying "a consumer takes an object and returns nothing". Or "a predicate is true when the string has exactly three characters". Most of the time, there is a confusion between the lambda expression, the abstract method it implements, and the functional interface that holds this method.

But since a functional interface, its abstract method, and a lambda expression that implements it are so closely linked together, this way of speaking actually makes total sense. So that's OK, as long as it does not lead to any ambiguity.

Let us write a lambda that consumes a String and prints on System.out . The syntax can be this one:

Here we directly wrote the simplified version of the lambda expression.

Implementing a Runnable

Implementing a Runnable turns out to write an implementation of void run() . This block of arguments is empty, so it should be written with parentheses. Remember: you can omit the parentheses only if you have one argument, here we have zero.

So let us write a runnable that tells us that it is running:

Calling a Lambda Expression

Let us go back to our previous Predicate example, and suppose that this predicate has been defined in a method. How can you use it to test if a given string of characters is indeed of length 3?

Well, despite the syntax you used to write a lambda, you need to keep in mind that this lambda is an instance of the interface Predicate . This interface defines a method called test() that takes a String and returns a boolean .

Let us write that in a method:

Note how you defined the predicate, just as you did in the previous example. Since the Predicate interface defines this method boolean test(String) , it is perfectly legal to call the methods defined in Predicate through a variable of type Predicate . This may look confusing at first, since this predicate variable does not look like it defines methods.

Bear with us, there are much better way to write this code, that you will see later in this tutorial.

So everytime you write a lambda, you can call any method defined on the interface this lamdba is implementing. Calling the abstract method will call the code of your lambda itself, since this lambda is an implementation of that method. Calling a default method will call the code written in the interface. There is no way a lambda can override a default method.

Capturing Local Values

Once you get used to them, writing lambdas becomes very natural. They are very well integrated in the Collections Framework, in the Stream API and in many other places in the JDK. Starting with Java SE 8, lambdas are everywhere, for the best.

There are constraints in using lambdas and you may come across compile-time errors that you need to understand.

Let us consider the following code:

Even if this code may look nice, trying to compile it will give you the following error on the use of totalPrice in this Consumer implementation:

Variable used in lambda expression should be final or effectively final

The reason is the following: lambdas cannot modify variables defined outside their body. They can read them, as long as they are final , that is, immutable. This process of accessing variable is called capturing : lambdas cannot capture variables, they can only capture values. A final variable is in fact a value.

You have noted that the error message tells us that the variable can be final , which is a classical concept in the Java language. It also tells us that the variable can be effectively final . This notion was introduced in Java SE 8: even if you do not explicitly declare a variable final , the compiler may do it for you. If it sees that this variable is read from a lambda, and that you do not modify it, then it will nicely add the final declaration for you. Of course this is done in the compiled code, the compiler does not modify your source code. Such variables are not called final ; they are called effectively final variables. This is a very useful feature.

Serializing Lambdas

Lambda expressions have been built so that they can be serialized.

Why would you serialize lambda expressions? Well, a lambda expression may be stored in a field, and this field may be accessed through a constructor or a setter method. Then you may have a lambda expression in the state of your object at runtime, without being aware of it.

So to preserve backward compatibility with existing serializable classes, serializing a lambda expression is possible.

More Learning

In this tutorial.

Last update: October 26, 2021

United States
United Kingdom

By Jeff Friesen , JavaWorld |

A beginner's library for learning about essential Java programming concepts, syntax, APIs, and packages.

Get started with lambda expressions in Java

Learn how to use lambda expressions and functional programming techniques in your java programs.

Before Java SE 8, anonymous classes were typically used to pass functionality to a method. This practice obfuscated source code, making it harder to understand. Java 8 eliminated this problem by introducing lambdas. This tutorial first introduces the lambda language feature, then provides a more detailed introduction to functional programming with lambda expressions along with target types. You'll also learn how lambdas interact with scopes, local variables, the this and super keywords, and Java exceptions.

Note that code examples in this tutorial are compatible with JDK 12.

Lambdas: A primer

A lambda expression (lambda) describes a block of code (an anonymous function ) that can be passed to constructors or methods for subsequent execution. The constructor or method receives the lambda as an argument. Consider the following example:

This example identifies a lambda for outputting a message to the standard output stream. From left to right, () identifies the lambda's formal parameter list (there are no parameters in the example), -> indicates that the expression is a lambda, and System.out.println("Hello") is the code to be executed.

Lambdas simplify the use of functional interfaces , which are annotated interfaces that each declare exactly one abstract method (although they can also declare any combination of default, static, and private methods). For example, the standard class library provides a java.lang.Runnable interface with a single abstract void run() method. This functional interface's declaration appears below:

The class library annotates Runnable with @FunctionalInterface , which is an instance of the java.lang.FunctionalInterface annotation type. FunctionalInterface is used to annotate those interfaces that are to be used in lambda contexts.

A lambda doesn't have an explicit interface type. Instead, the compiler uses the surrounding context to infer which functional interface to instantiate when a lambda is specified--the lambda is bound to that interface. For example, suppose I specified the following code fragment, which passes the previous lambda as an argument to the java.lang.Thread class's Thread(Runnable target) constructor:

The compiler determines that the lambda is being passed to Thread(Runnable r) because this is the only constructor that satisfies the lambda: Runnable is a functional interface, the lambda's empty formal parameter list () matches run() 's empty parameter list, and the return types ( void ) also agree. The lambda is bound to Runnable .

Listing 1 presents the source code to a small application that lets you play with this example.

Listing 1. LambdaDemo.java (version 1)

Compile Listing 1 ( javac LambdaDemo.java ) and run the application ( java LambdaDemo ). You should observe the following output:

Lambdas can greatly simplify the amount of source code that you must write, and can also make source code much easier to understand. For example, without lambdas, you would probably specify Listing 2's more verbose code, which is based on an instance of an anonymous class that implements Runnable .

Listing 2. LambdaDemo.java (version 2)

After compiling this source code, run the application. You'll discover the same output as previously shown.

Java lambdas in depth

To use lambdas effectively, you must understand the syntax of lambda expressions along with the notion of a target type. You also need to understand how lambdas interact with scopes, local variables, the this and super keywords, and exceptions. I'll cover all of these topics in the sections that follow.

Lambda syntax

Every lambda conforms to the following syntax:

The formal-parameter-list is a comma-separated list of formal parameters, which must match the parameters of a functional interface's single abstract method at runtime. If you omit their types, the compiler infers these types from the context in which the lambda is used. Consider the following examples:

You must specify parentheses for multiple or no formal parameters. However, you can omit the parentheses (although you don't have to) when specifying a single formal parameter. (This applies to the parameter name only--parentheses are required when the type is also specified.) Consider the following additional examples:

The formal-parameter-list is followed by a -> token, which is followed by expression-or-statements --an expression or a block of statements (either is known as the lambda's body). Unlike expression-based bodies, statement-based bodies must be placed between open ( { ) and close ( } ) brace characters:

The first example's expression-based lambda body doesn't have to be placed between braces. The second example converts the expression-based body to a statement-based body, in which return must be specified to return the expression's value. The final example demonstrates multiple statements and cannot be expressed without the braces.

Listing 3 presents a simple application that demonstrates lambda syntax; note that this listing builds on the previous two code examples.

Listing 3. LambdaDemo.java (version 3)

Listing 3 first introduces the BinaryCalculator and UnaryCalculator functional interfaces whose calculate() methods perform calculations on two input arguments or on a single input argument, respectively. This listing also introduces a LambdaDemo class whose main() method demonstrates these functional interfaces.

The functional interfaces are demonstrated in the static double calculate(BinaryCalculator calc, double v1, double v2) and static double calculate(UnaryCalculator calc, double v) methods. The lambdas pass code as data to these methods, which are received as BinaryCalculator or UnaryCalculator instances.

Compile Listing 3 and run the application. You should observe the following output:

Target types

A lambda is associated with an implicit target type , which identifies the type of object to which a lambda is bound. The target type must be a functional interface that's inferred from the context, which limits lambdas to appearing in the following contexts:

Variable declaration
Return statement
Array initializer
Method or constructor arguments
Lambda body
Ternary conditional expression
Cast expression

Listing 4 presents an application that demonstrates these target type contexts.

Listing 4. LambdaDemo.java (version 4)

Programming Languages
Functions as a Service

Guide to Functional Interfaces and Lambda Expressions in Java

Introduction

Java is an object-oriented language, imperative in its essence (contrasting with the declarative practice that is functional programming). Nonetheless, it was possible to apply functional principles to Java programs prior to version 8, however it required additional work to bypass the innate structure of the language and resulted in convoluted code. Java 8 brought about ways to harness the true efficacy and ease to which functional programming aspires.

This guide aims to provide a holistic view into functional programming, a concept that appears rather esoteric to the developer of OOP background. Because of this, material is oftentimes scattered and scarce. We will first establish an understanding of the core concepts of functional programming and the ways in which Java implements them.

Because there's a lot of misunderstanding regarding Functional Programming for those with an OOP background - we'll start out with a primer on Functional Programming and its benefits.

Then, we'll dive into Lambda Expressions as Java's implementation of first-class functions , as well as functional interfaces , followed by a quick look at Java's function package.

Primer on Functional Programming

Functional programming is a programming paradigm that revolves around - well, functions . Although object-oriented programming also employs functions, the building blocks of the program are the objects. Objects are used to mediate the state and behavior patterns inside the program, while functions are there to take care of the control flow.

Functional programming separates behavior from objects.

Functions then have the liberty to act as first-class entities. They can be stored in variables and can be arguments or the return values of other functions without needing to be accompanied by an object. These discrete entities are termed first-class functions , while the functions enclosing them are named higher-order functions .

Functional programming also has a different approach towards the program state. In OOP, the desired outcome of an algorithm is achieved by manipulating the state of the program. Functional practice refrains from causing state changes altogether. The functions are generally pure , meaning that they do not cause any side effects; they don't alter global variables, perform IO or throw exceptions.

There exist purely functional languages, some of which enforce the use of immutable variables. There also exist purely object-oriented languages. Java is a multi paradigm language; it has the ability to teeter between different programming styles and utilize the benefits of multiple paradigms in the same code-base.

The Benefits of Functional Programming

Functional programming, among all else, offers flexibility. We can create layers of generalization. We can scaffold behavioral patterns and customize them by passing in additional instructions when needed.

Object-oriented programming also has ways to create these patterns, though they depend on the use of objects. Interfaces, for example, can be used to create a scaffold, and each class implementing the interface can tailor the behavior defined in its own way. Then again, an object should always be there to carry the variants. Functional programming provides a more elegant way.

Furthermore, functional programming uses pure functions. Since pure functions can not alter states outside of their scope, they do not have the power to affect one another; each function is fully independent . This gives programmers the ability to dispose of the functions when they are no longer needed, alter the execution order at will, or execute functions in parallel.

Since pure functions are not dependent on external values, re-executing the code with the same arguments will result in the same outcome every time. This supports the optimization technique called memoization (not "memorization"), the process of caching the results of an expensive execution sequence to retrieve them when needed elsewhere in the program.

Additionally, the ability to treat functions as first-class entities allows for currying - the technique of subdividing the execution sequence of a function to perform at separate times. A function with multiple parameters can be partially executed at the point where one parameter is supplied, and the rest of the operation can be stored and delayed until the next parameter is given.

Lambda Expressions in Java
Functional Interfaces and Lambda Expressions

Java implements the basic block of functional programming, the pure first-class functions , in the form of lambda expressions .

Lambda expressions are the couriers via which Java moves around a set of behavior.

Lambda expressions, by and large, have the structure of:

Then again, this structure is subject to change. Let's see the lambdas in action first and elaborate on the adapted versions of their syntax later on. We'll start off by defining a functional interface :

A functional interface is an interface that has exactly one abstract method.

We can then implement this interface's method, through a lambda expression:

With this implementation, the concat() method now has a body and can be used later on:

Let's take a step back and peel away at what we just did. The StringConcat interface holds a single abstract method ( concat() ) which takes two string parameters and is expected to return a string value.

StringConcat is an interface and can not be instantiated. On the right-hand side of the assignment, the compiler expects to find an instantiation of a class that implements StringConcat , not a function. Yet, the code works seamlessly.

Java is inherently object-oriented. Everything is an object in Java (more accurately, everything extends into an Object class), including lambda expressions.

Even though we get to treat lambdas as first-class functions, Java interprets them as objects. Intrinsic in that, the lambda expression assigned to be of type StringConcat is essentially an implementing class and therefore has to define the behavior for StringConcat 's method .

The concat() method can be called in the same way object methods are called ( lambdaConcat.concat() ), and it behaves as defined by the lambda expression:

At the end of the program execution, console should read:

Lambdas as Arguments

Lambdas shine more when they're passed in as arguments to methods, instead of used as utility classes. Let's implement a function that filters through a list of people to find a set statistically likely to be "likable" by some set standard.

Note: Our standard for "friendliness" will be set just for illustrational purposes, and doesn't reflect any real research or statistical analysis.

The function will accept a mass and bias to filter out the mass ending up with a group of people that are, according to the opinion applied, "nice people":

The bias in the parameter list will be a function - a lambda expression - that the higher-order function refers to decide the appeal of each person in the mass.

Let's start by creating a Person class to represent a person:

The Person class is assigned various fields to outline each of their characters. Each Person has a name, age, a sociability signifier, a pet preference selected among a set of constants, and a list of hobbies.

With a Person class, let's go ahead, defining a Bias functional interface with a test() function. The test() function will, naturally, be abstract and without implementation by default:

Once we implement it, the test() function will test a person for their likability, according to some set of biases. Let's go ahead and define the filter() function as well, which accepts a list of people and a Bias for filtering:

Based on the result of the test() function, we either add or skip adding a person to the filteredPeople list, which is, well, how filters work. Keep in mind that the actual implementation of the test() function still doesn't exist, and will only gain body after we define its body as a lambda function.

Since the filter() method accepts the Bias functional interface, we can anonymously create the lambda function in the filter() call:

Finally, this is where it all comes together - we've defined the body of the functional interface via a lambda expression:

The lambda expression gets evaluated and compared against the signature of Bias 's test() method and this body is then used as the test() method's check, and returns a true or false based on the value of the isExtrovert() method.

Keep in mind that we could've used anybody here, since Bias is a "plug-and-play" functional interface.

The ability to create a method that can adjust its approach in this manner is a delicacy of functional programming.

The filter() method is a higher-degree function that takes another function as its parameter according to which it alters its behavior, where the other function is fully fluid.

There exist myriad ways in which we can select a Person to hang out with. Putting the ethics of filtering like this to the side, we may choose to hang out with people of a certain age scope, prefer extroverts, or we may be desperate to find someone who would go to the gym with us yet be disinclined to share their cat stories.

Various selection criteria can be chained together as well.

Of course, it is possible to create different methods to serve each scenario - yet does it make sense to purchase different drills to use on different materials when you can simply change the drill bits?

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

The filter() method provides flexibility. It defines the main behavior, selecting . Later on, in the program, we can use this method for any selection and just pass in " how to" .

It's worth noting that the filter() method starts by creating a new ArrayList , as functional practice refrains from changing the state of the program. Instead of operating on and manipulating the original list, we start with an empty list which we later populate with desired Person s.

The list holding only the extroverts is then passed to list() to be displayed in the console:

This example showcases the flexibility and liquidity of functional interfaces and their lambda-created bodies.

Lambdas and Interfaces

So far, the lambda expressions were ascribed to an interface. This will be the norm any time we want to implement first-class functions in Java.

Consider the implementation of arrays. When an array's elements are needed somewhere in the code, we call the array by its assigned name and access its elements through that name instead of moving the actual set of data around. And since we have declared it to be an array of one type, every time we want to operate on it, the compiler knows that the variable name is referring to an array and that this array stores objects of a significant type. The compiler thus can decide the capabilities of this variable and the actions it can perform.

Java is a statically-typed language - it requires this knowledge for every variable.

Every variable must state its name and its type before it can be used (this is called declaring a variable). Lambda expressions are not an exception to this rule.

When we want to use lambda expressions, we need to let the compiler know the nature of the encapsulated behavior. The interfaces we bind to lambda expressions are there to provide this information; they act as footnotes the compiler can refer to.

We could carry the name and type information along with the lambda expression itself. However, more often than not, we will use the same type of lambdas to create a variety of particular behaviors.

It's good practice to avoid redundancy in the code; typing the same information many times over will only make our code error-prone and our fingers weary.

Lambda Expression Syntax

Lambdas come in many flavors. While the lambda operator ( -> ) is set firm, brackets and type declarations can be removed in some circumstances.

Lambda takes its simplest form when there only exists one parameter and one operation to perform inside the function body.

We no longer need parentheses around the parameter, no type declaration needed, no curly brackets enclosing the statement, and no requirement to use the return keyword.

The lambda expression can take more than one parameter or may not take any. In those cases, we are bound to include parentheses:

If the function body includes more than one statement, the curly braces and, if the return type is not void, the return keyword are also required:

The type declaration for the parameters can be omitted fully. Though if one parameter amongst many has its type declared, others are required to follow in its footsteps:

Both statements above are valid. However, the compiler would complain if the program were to use the expression below:

Functional Interfaces
@FunctionalInterface

Any interface with a single abstract method qualifies to be a functional interface; there is no additional requirement. Yet, a distinction may be necessary for large codebases.

Let's take the Bias interface from Lambdas as Arguments , and add another abstract method to it:

The Bias interface was connected to a lambda expression, yet the compiler does not complain if we add another method to the interface, which turns it from a functional interface to a regular one.

The compiler has no way of knowing that Bias was supposed to be a functional interface until it encounters the lambda expression bound to it. Since a regular interface can have many abstract methods (and since there is no indication that this interface is not like any other), the compiler will blame the lambda expression for it tries to bind to a non-functional interface.

To avoid this, Java provides a way to mark the interfaces that serve lambda expressions, explicitly:

The @FunctionalInterface annotation will let the compiler know that this interface is meant to be functional, and therefore any additional abstract method is not welcome here.

The compiler can now interfere on the spot when someone makes the mistake of adding another method to this interface, though the chances of that are lowered yet again by the @FunctionalInterface mark.

Default and Static Methods

Up until Java 8, interfaces were limited to having abstract methods and constants. Along with functional programming support came the addition of default and static methods to interface definitions.

An abstract method defines a skeleton for the method to be implemented. A default method, on the other hand, is no mere skeleton; it is explicitly defined. Yet, an implementing class is given the option to override the default methods. If they don't, the default implementation kicks in:

Let's implement this interface without implementing the bark() method:

Now, let's instantiate it and take a look at the default implementation kicking in:

A static method of an interface, on the other hand, is the private property of that interface. It can only be called via the interface name and cannot be overridden by the implementing classes:

Let's implement the interface:

And instantiate a GermanSheperd :

This results in:

The java.util.function Package

The extent of information functional interfaces provide is limited. The method definitions can easily be generalized to cover common use cases, and they can be fairly flexible in their implementations.

The return type of the abstract method can be any of the primitive types (integer, string, double, etc.) or can be void. Any classes that are defined inside the program can also be declared as the return type, though the generic type would cover all.

The same logic applies to the parameter types. Even though the number of parameters to a method can still vary, there exists a logical limit for the sake of code quality. The list of names that can be assigned to a function is also limitless, though it rarely matters.

In the end, we are left with a handful of permutations that can cover most of the common use cases.

Java employs 43 predefined functional interfaces, in the java.util.function package, to serve these scenarios. We can group them in five groups:

In their individual guides - we'll be covering each of these groups separately.

In this guide, we've taken a holistic look at Functional Programming in Java and its implementation. We've covered Functional Interfaces, as well as Lambda Expressions as the building blocks for functional code.

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

InfoQ Software Architects' Newsletter

A monthly overview of things you need to know as an architect or aspiring architects.

View an example

We protect your privacy.

Facilitating the Spread of Knowledge and Innovation in Professional Software Development

English edition
Chinese edition
Japanese edition
French edition

Back to login

Login with:

Don't have an infoq account, helpful links.

About InfoQ
InfoQ Editors
Write for InfoQ
About C4Media

Choose your language

Discover transformative insights to level up your software development decisions. Register now with early bird tickets.

Get practical advice from senior developers to navigate your current dev challenges. Register now with early bird tickets.

Level up your software skills by uncovering the emerging trends you should focus on. Register now.

Your monthly guide to all the topics, technologies and techniques that every professional needs to know about. Subscribe for free.

InfoQ Homepage Articles Lambdas in Java: An In-Depth Analysis

Lambdas in Java: An In-Depth Analysis

This item in japanese

Jun 03, 2010 13 min read

Alex Blewitt

InfoQ Article Contest

With the acquisition of Sun Microsystems out of the way, Oracle can get down to the serious business of revitalising what many have come to see as a stagnant language. High on many people's requirements is the ability to be able to pass functions around that are independent of classes, so that functions can be used as arguments to other function or method calls. Functional languages like Haskell and F# exist purely using this paradigm, and functional programming goes back eight decades to the Lambda Calculus , leading to the term Lambda being used in many languages to describe anonymous functions.

Although languages like Python and Ruby have had lambdas for a long time, the recent popularity of JVM-based languages (notably Groovy and Scala) have rekindled demand for lambdas in Java as well. So when it was announced and proposed as an OpenJDK project , many were excited, even if they were confused between lambdas and closures . There is also an InfoQ news post available for those interested in learning more about this discussion (including the debate over the syntax of lambdas in Java).

Lambdas and Closures

Rate this Article

This content is in the architecture topic, related topics:.

Development
Architecture

Related Editorial

Popular across infoq, building saas from scratch using cloud-native patterns: a deep dive into a cloud startup, yelp overhauls its streaming architecture with apache beam and apache flink, java news roundup: jobrunr 7.0, introducing the commonhaus foundation, payara platform, devnexus, production comes first - an outside-in approach to building microservices by martin thwaites, courtney nash discusses incident management, automation, and the void report, kubecon eu: mercedes-benz’s migration from pod security policies to validation admission policies, related content, the infoq newsletter.

A round-up of last week’s content on InfoQ sent out every Tuesday. Join a community of over 250,000 senior developers. View an example

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
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...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

We Love Servers.

WHY IOFLOOD?
BARE METAL CLOUD
DEDICATED SERVERS

Java Lambda Expressions Explained: From Basics to Mastery

Stylized java lambda symbol in a modern minimalist style

Are you finding it challenging to grasp Java lambda expressions? You’re not alone. Many developers find themselves puzzled when it comes to understanding and implementing lambda expressions in Java. But don’t worry, we’re here to help.

Think of Java lambda expressions as a shorthand way to define anonymous functions in Java. They are a powerful tool that can make your code more concise, readable, and functional-oriented.

This guide will walk you through the basics of lambda expressions, their syntax, and how to use them effectively. We’ll cover everything from the basics to more advanced techniques, as well as alternative approaches. So, let’s dive in and start mastering Java lambda expressions!

TL;DR: What are Java Lambda Expressions and How Do I Use Them?

Java lambda expressions are a way to define anonymous functions in Java, used with the syntax (parameter) -> expression . They are a powerful tool that can make your code more concise, readable, and functional-oriented.

Here’s a simple example:

This lambda expression takes two integers, a and b, and returns their product. It’s a simple yet powerful concept that can greatly enhance your Java programming skills.

But there’s much more to Java lambda expressions than just this. Continue reading for more detailed information and advanced usage scenarios.

Table of Contents

Understanding Java Lambda Expressions: The Basics

Exploring advanced java lambda expressions, exploring alternatives to java lambda expressions, troubleshooting java lambda expressions, the fundamentals of functional programming in java, the relevance of java lambda expressions in modern development, wrapping up: mastering java lambda expressions.

Java lambda expressions are a fundamental concept in functional programming. They provide a way to create anonymous functions, which are functions without a name. This feature is particularly useful when you want to pass a function as a method argument.

Syntax of Java Lambda Expressions

The syntax of a lambda expression is simple:

Here, the parameter is the input received by the function, and the expression is the operation performed on the input.

Let’s break down a simple example:

In this lambda expression, (int x, int y) are the parameters, and x + y is the expression. This function takes two integers as input and returns their sum.

Advantages of Using Lambda Expressions

Lambda expressions have several advantages:

They make your code more concise and readable.
They support functional programming, making your code more flexible and reusable.

Potential Pitfalls

However, there are a few things to watch out for:

Overusing lambda expressions can make your code harder to read and debug, especially for developers not familiar with the concept.
Lambda expressions lack a name and documentation, which can make your code harder to understand.

In the next section, we’ll explore more advanced uses of Java lambda expressions.

As you get more comfortable with Java lambda expressions, you can start to leverage their power with functional interfaces, streams, and collections.

Lambda Expressions and Functional Interfaces

A functional interface in Java is an interface with exactly one abstract method. Lambda expressions can be used as an instance of a functional interface. Let’s take a look at an example:

In this example, we define a functional interface Greeting with one abstract method sayHello . We then create a lambda expression that implements this interface and use it to print a greeting message.

Lambda Expressions with Streams and Collections

Lambda expressions work exceptionally well with Java’s Stream API and Collections. They allow you to perform complex operations like filtering and mapping on collections of data in a concise and readable way. For example:

In this example, we create a list of numbers and use a lambda expression to filter out the even numbers and print them. The filter method takes a lambda expression that defines the condition for filtering.

Best Practices

When using lambda expressions, keep these best practices in mind:

Use lambda expressions when you need to pass a piece of code as a method argument.
Keep your lambda expressions small and simple. If your lambda expression is getting complex, it’s better to define a method and refer to it.
Always use lambda expressions with functional interfaces, streams, and collections for better efficiency and readability.

While Java lambda expressions are a powerful tool, they are not the only way to accomplish tasks in a functional style in Java. There are other methods, such as using anonymous inner classes, that can also be effective in certain scenarios.

Anonymous Inner Classes

Before lambda expressions were introduced in Java 8, anonymous inner classes were a common way to define and instantiate a class at the same time. They are particularly useful when you need a one-time-use class.

Here’s an example of using an anonymous inner class to define a Runnable :

In this example, we create a new Runnable using an anonymous inner class. We override the run method to print a message, and then we call run to execute it.

Advantages and Disadvantages of Anonymous Inner Classes

Anonymous inner classes have their own set of advantages and disadvantages:

Advantages : They allow you to define and instantiate a class at the same time. They are also more flexible than lambda expressions because they can contain state and have multiple methods.

Disadvantages : They are more verbose than lambda expressions. They also can’t be used in functional interfaces, which limits their usefulness in functional programming.

Recommendations

While lambda expressions are generally more concise and readable than anonymous inner classes, there are still cases where using an anonymous inner class might be the better choice. For example, if you need a class with state or multiple methods, an anonymous inner class would be more appropriate.

Remember, the right tool depends on the task at hand. It’s important to understand the strengths and weaknesses of each tool and choose the one that best suits your needs.

As with any coding concept, you might encounter some hurdles when working with Java lambda expressions. Here, we’ll discuss common issues and provide solutions and workarounds.

Syntax Errors

One common problem is syntax errors, which occur when the structure of your lambda expression doesn’t align with Java’s language rules. For example, forgetting the arrow ( -> ) in your lambda expression will result in a syntax error.

In the incorrect example, the arrow ( -> ) is missing, causing a syntax error. The correct example includes the arrow, forming a proper lambda expression.

Type Mismatches

Lambda expressions are strongly typed, which means the types of the parameters must match the types expected by the context. If they don’t match, you’ll get a type mismatch error.

For example, consider the following code:

In the incorrect example, we’re trying to assign a lambda expression that expects an Integer parameter to a Predicate. This results in a type mismatch error. The correct example uses a String parameter, matching the Predicate type.

Tips for Using Lambda Expressions

To avoid these and other issues when using lambda expressions:

Always double-check your lambda expression’s syntax.
Ensure the types of your lambda expression’s parameters match the expected types.
Use your IDE’s error highlighting and auto-completion features to spot and fix errors early.

To truly understand Java lambda expressions, it’s crucial to have a solid grasp of functional programming in Java. This programming paradigm emphasizes immutability, stateless functions, and the use of expressions instead of statements.

Functional Programming and Lambda Expressions

Lambda expressions are a cornerstone of functional programming. They allow us to treat functions as first-class citizens, meaning we can pass functions around just like any other variable. This leads to more concise, readable, and flexible code.

Here’s a simple example of using a lambda expression to create a function that doubles an integer:

In this example, we define a Function that takes an Integer and returns another Integer . The lambda expression (Integer x) -> x * 2 doubles the input number. We then apply this function to the number 5, and the output is 10.

Functional Interfaces and Method References

Functional interfaces and method references are two other key concepts in functional programming with Java.

A functional interface is an interface with exactly one abstract method. Java 8 introduced the @FunctionalInterface annotation to indicate that an interface is meant to be a functional interface. Lambda expressions can be used as instances of a functional interface.

Method references are a shorthand notation for a lambda expression that calls an existing method. They use the :: symbol to point to an existing method.

Here’s an example of using a method reference to print all elements of a list:

In this example, System.out::println is a method reference that points to the println method of System.out . The forEach method takes this method reference and applies it to each element of the list.

By understanding these fundamentals, you’ll be well-equipped to make the most of lambda expressions in your Java code.

Java lambda expressions are not just an academic concept, they play a crucial role in modern Java development. Their relevance extends to various areas, including event handling, multithreading, and more.

Lambda Expressions in Event Handling

Lambda expressions have simplified event handling in Java, making the code more readable and concise. Here’s an example of using a lambda expression to handle a button click event in a JavaFX application:

In this example, the lambda expression e -> System.out.println("Button clicked") is used to handle the button click event. When the button is clicked, the message “Button clicked” is printed to the console.

Lambda Expressions in Multithreading

Lambda expressions also play a significant role in multithreading in Java. They can be used to create threads in a more concise and readable way. Here’s an example:

In this example, the lambda expression () -> System.out.println("New thread created") is used to create a new thread that prints a message to the console.

Exploring Related Concepts

If you’re interested in going beyond lambda expressions, there are several related concepts that you might find interesting:

Java streams provide a way to process data in a declarative way. They work exceptionally well with lambda expressions.
Functional interfaces are interfaces with a single abstract method and are a key concept in functional programming in Java.

Further Resources for Mastering Java Lambda Expressions

To deepen your understanding of Java lambda expressions and related concepts, check out the following resources:

IOFlood’s Java Object Oriented Programming Concepts Guide covers topics such as the importance of abstract classes in Java inheritance.

Java Design Patterns – Learn about creational, structural, and behavioral design patterns like Singleton and Observer.

Serialization in Java – Understand serialization in Java for converting object state into a byte stream.

Oracle’s Java Tutorials provide a comprehensive guide to lambda expressions in Java.

Baeldung’s Guide to Java 8’s Lambdas offers practical tips and best practices for using lambda expressions.

GeeksforGeeks’ Java Lambda Expressions explains lambda expressions with a variety of examples and exercises.

In this comprehensive guide, we’ve navigated the world of Java Lambda Expressions, a powerful tool in functional programming. We’ve explored their syntax, usage, advantages, and common pitfalls, providing you with a deep understanding of this crucial Java feature.

We began with the basics, understanding the syntax and basic use of lambda expressions. We then delved into more advanced territory, learning how to use lambda expressions with functional interfaces, streams, and collections. Along the way, we tackled common issues that you might encounter when using lambda expressions, providing solutions and workarounds for each problem.

We also looked at alternative approaches to functional programming in Java, comparing lambda expressions with anonymous inner classes. Here’s a quick comparison of these methods:

Whether you’re just starting your journey with Java lambda expressions or looking to deepen your understanding, we hope this guide has been a valuable resource. With the knowledge you’ve gained, you’re now well-equipped to harness the power of lambda expressions in your Java programming.

Remember, the right tool depends on the task at hand. Understanding the strengths and weaknesses of each tool, and choosing the one that best suits your needs, is the key to effective programming. Happy coding!

About Author

Gabriel Ramuglia

Gabriel is the owner and founder of IOFLOOD.com , an unmanaged dedicated server hosting company operating since 2010.Gabriel loves all things servers, bandwidth, and computer programming and enjoys sharing his experience on these topics with readers of the IOFLOOD blog.

Working with layers for Java Lambda functions

A Lambda layer is a .zip file archive that contains supplementary code or data. Layers usually contain library dependencies, a custom runtime , or configuration files. Creating a layer involves three general steps:

Package your layer content. This means creating a .zip file archive that contains the dependencies you want to use in your functions.

Create the layer in Lambda.

Add the layer to your functions.

This topic contains steps and guidance on how to properly package and create a Java Lambda layer with external library dependencies.

Prerequisites

Java layer compatibility with amazon linux, layer paths for java runtimes, packaging the layer content, creating the layer, adding the layer to your function.

To follow the steps in this section, you must have the following:

Apache Maven 3.8.6 or later

AWS Command Line Interface (AWS CLI) version 2

Ensure that the Java version that Maven refers to is the same as the Java version of the function that you intend to deploy. For example, for a Java 21 function, the mvn -v command should list Java version 21 in the output:

Throughout this topic, we reference the layer-java sample application on the awsdocs GitHub repository. This application contains scripts that download the dependencies and generate the layer. The application also contains a corresponding function that uses dependencies from the layer. After creating a layer, you can deploy and invoke the corresponding function to verify that everything works properly. Because you use the Java 21 runtime for the functions, the layers must also be compatible with Java 21.

The layer-java sample application contains a single example within two sub-directories. The layer directory contains a pom.xml file that defines the layer dependencies, as well as scripts to generate the layer. The function directory contains a sample function to help test that the layer works. This tutorial walks through how to create and package this layer.

The first step to creating a layer is to bundle all of your layer content into a .zip file archive. Because Lambda functions run on Amazon Linux , your layer content must be able to compile and build in a Linux environment.

Java code is designed to be platform-independent, so you can package your layers on your local machine even if it doesn't use a Linux environment. After you upload the Java layer to Lambda, it'll still be compatible with Amazon Linux.

When you add a layer to a function, Lambda loads the layer content into the /opt directory of that execution environment. For each Lambda runtime, the PATH variable already includes specific folder paths within the /opt directory. To ensure that the PATH variable picks up your layer content, your layer .zip file should have its dependencies in the following folder paths:

For example, the resulting layer .zip file that you create in this tutorial has the following directory structure:

The layer-java-layer-1.0-SNAPSHOT.jar JAR file (an uber-jar that contains all of our required dependencies) is correctly located in the java/lib directory. This ensures that Lambda can locate the library during function invocations.

In this example, you package the following two Java libraries into a single JAR file:

aws-lambda-java-core – A minimal set of interface definitions for working with Java in AWS Lambda

Jackson – A popular suite of data-processing tools, particularly for working with JSON.

Complete the following steps to install and package the layer content.

To install and package your layer content

Clone the aws-lambda-developer-guide GitHub repo , which contains the sample code that you need in the sample-apps/layer-java directory.

Navigate to the layer directory of the layer-java sample app. This directory contains the scripts that you use to create and package the layer properly.

Examine the pom.xml file. In the <dependencies> section, you define the dependencies that you want to include in the layer, namely the aws-lambda-java-core and jackson-databind libraries. You can update this file to include any dependencies that you want to include in your own layer.

Example pom.xml

The <build> section of this pom.xml file contains two plugins. The maven-compiler-plugin compiles the source code. The maven-shade-plugin packages your artifacts into a single uber-jar.

Ensure that you have permissions to run both scripts.

Run the 1-install.sh script using the following command:

This script runs mvn clean install in the current directory. This creates the uber-jar with all required dependencies in the target/ directory.

Example 1-install.sh

Run the 2-package.sh script using the following command:

This script creates the java/lib directory structure that you need to properly package your layer content. It then copies the uber-jar from the /target directory into the newly created java/lib directory. Finally, the script zips the contents of the java directory into a file named layer_content.zip . This is the .zip file for your layer. You can unzip the file and verify that it contains the correct file structure, as shown in the Layer paths for Java runtimes section.

Example 2-package.sh

In this section, you take the layer_content.zip file that you generated in the previous section and upload it as a Lambda layer. You can upload a layer using the AWS Management Console or the Lambda API via the AWS Command Line Interface (AWS CLI). When you upload your layer .zip file, in the following PublishLayerVersion AWS CLI command, specify java21 as the compatible runtime and arm64 as the compatible architecture.

From the response, note the LayerVersionArn , which looks like arn:aws:lambda:us-east-1: 123456789012 :layer:java-jackson-layer:1 . You'll need this Amazon Resource Name (ARN) in the next step of this tutorial, when you add the layer to your function.

In this section, you deploy a sample Lambda function that uses the Jackson library in its function code, then you attach the layer. To deploy the function, you need a Lambda execution role . If you don't have an existing execution role, follow the steps in the collapsible section. Otherwise, skip to the next section to deploy the function.

To create an execution role

Open the roles page in the IAM console.

Choose Create role .

Create a role with the following properties.

Trusted entity – Lambda .

Permissions – AWSLambdaBasicExecutionRole .

Role name – lambda-role .

The AWSLambdaBasicExecutionRole policy has the permissions that the function needs to write logs to CloudWatch Logs.

To deploy the Lambda function

Navigate to the function/ directory. If you're currently in the layer/ directory, then run the following command:

Review the function code . The function takes in a Map<String, String> as input, and uses Jackson to write the input as a JSON String before converting it into a pre-defined F1Car Java object. Finally, the function uses fields from the F1Car object to construct a String that the function returns.

Build the project using the following Maven command:

This command produces a JAR file in the target/ directory named layer-java-function-1.0-SNAPSHOT.jar .

Deploy the function. In the following AWS CLI command, replace the --role parameter with your execution role ARN:

At this point, you can optionally try to invoke your function before attaching the layer. If you try this, then you should get a ClassNotFoundException because your function cannot reference the requests package. To invoke your function, use the following AWS CLI command:

You should see output that looks like this:

To view the specific error, open the output response.json file. You should see a ClassNotFoundException with the following error message:

Next, attach the layer to your function. In the following AWS CLI command, replace the --layers parameter with the layer version ARN that you noted earlier:

Finally, try to invoke your function using the following AWS CLI command:

This indicates that the function was able to use the Jackson dependency to properly execute the function. You can check that the output response.json file contains the correct returned String:

You can now delete the resources that you created for this tutorial, unless you want to retain them. By deleting AWS resources that you're no longer using, you prevent unnecessary charges to your AWS account.

To delete the Lambda layer

Open the Layers page of the Lambda console.

Select the layer that you created.

Choose Delete , then choose Delete again.

To delete the Lambda function

Open the Functions page of the Lambda console.

Select the function that you created.

Choose Actions , Delete .

Type delete in the text input field and choose Delete .

To use the Amazon Web Services Documentation, Javascript must be enabled. Please refer to your browser's Help pages for instructions.

Thanks for letting us know we're doing a good job!

If you've got a moment, please tell us what we did right so we can do more of it.

Thanks for letting us know this page needs work. We're sorry we let you down.

If you've got a moment, please tell us how we can make the documentation better.

IMAGES

Lambda Expression Java
Best practices when you use Lambda expressions in Java
java
Lambda Expression in Java 8
Learn Java lambda syntax quickly by example
Lambda Expression in Java 8

VIDEO

#5 Потоки данных / Java Lambdas / Source Code
#08 AWS Lambda Layer with example
Java Lambda and Stream Full Course
Smart Migration to JDK 8
Java Lambda Gems: Even Number Finder Tutorial 💎
Lambda Expression in Java

COMMENTS

How do you assign a lambda to a variable in Java 8?
Depending on context, adding an explicit {} block around the lambda will help add clarity and may be required. With that, you would get something like: BiFunction<String, Integer, Integer> x = (String k, Integer v) -> {v == null ? 42 : v + 41};
Java Lambda Expressions (With Examples)
Here is how we can define lambda expression in Java. (parameter list) -> lambda body. 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: double getPiValue() {. return 3.1415;
Lambda Expressions (The Java™ Tutorials > Learning the Java Language
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
Lambda Expressions and Functional Interfaces: Tips and Best ...
2. Prefer Standard Functional Interfaces. Functional interfaces, which are gathered in the java.util.function package, satisfy most developers' needs in providing target types for lambda expressions and method references. Each of these interfaces is general and abstract, making them easy to adapt to almost any lambda expression.
Java Lambda Expressions
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.
Lambda Expression in Java
return is a control-flow statement. To make this lambda valid, curly braces are required as follows: (Integer i) -> { return "geeksforgeeks" + i; }. "geeks for geeks" is an expression, not a statement. To make this lambda valid, you can remove the curly braces and semicolon as follows: (String s) -> "geeks for geeks".
Java 8 Lambda Expression (with Examples)
In Java, a lambda expression is an expression that represents an instance of a functional interface. Similar to other types in Java, lambda expressions are also typed, and their type is a functional interface type. To infer the type, the compiler looks at the left side of the assignment in a lambda expression.
Java Lambda Expressions
Java lambda expressions are Java's first steps into functional programming. This tutorial explains how Java lambda expressions work, how they are defined and how you use them. ... You can assign a lambda expression to a variable and pass it around, like you do with any other object. Here is an example: public interface MyComparator { public ...
Lambda Expressions in Java
Introduction. Lambda functions have been an addition that came with Java 8, and was the language's first step towards functional programming, following a general trend toward implementing useful features of various compatible paradigms.. The motivation for introducing lambda functions was mainly to reduce the cumbersome repetitive code that went into passing along class instances to simulate ...
Writing Your First Lambda Expression
Writing a First Lambda Expression that implements Predicate<String> Now for the last part: writing the lambda itself. What you need to understand is that the lambda expression you are writing is an implementation of the abstract method you found. Using the lambda expression syntax, you can nicely inline this implementation in your code.
Get started with lambda expressions in Java
Java 8 eliminated this problem by introducing lambdas. This tutorial first introduces the lambda language feature, then provides a more detailed introduction to functional programming with lambda ...
Guide to Functional Interfaces and Lambda Expressions in Java
Lambda Expressions in Java Functional Interfaces and Lambda Expressions. Java implements the basic block of functional programming, the pure first-class functions, ... On the right-hand side of the assignment, the compiler expects to find an instantiation of a class that implements StringConcat, not a function. Yet, the code works seamlessly. ...
Lambdas in Java: An In-Depth Analysis
(You can do pure lambdas in Python with lambda x:x+1, and assign the result to a variable or store in another ... The proposed syntax for representing a lambda in Java is using the # character ...
Java
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 ...
Java 8 lambdas. An easy explanation
Step 7: Using standard interfaces. Obviously, a method that acts on an object and returns a boolean is so common, that it would be weird if Java didn't support that out-of-the-box. Fortunately ...
Taming the Lambda: A Practical Guide to Java 8 Lambda Expressions
Java Streams: The Stream API introduced in Java 8 allows you to perform operations on collections in a functional style. Lambda expressions are used extensively with streams for filtering, mapping ...
Java Lambda Expressions Explained: From Basics to Mastery
Think of Java lambda expressions as a shorthand way to define anonymous functions in Java. They are a powerful tool that can make your code more concise, readable, and functional-oriented. This guide will walk you through the basics of lambda expressions, their syntax, and how to use them effectively.
Why Do We Need Effectively Final?
Lambda expressions can use variables defined in an outer scope. We refer to these lambdas as capturing lambdas.They can capture static variables, instance variables, and local variables, but only local variables must be final or effectively final.. In earlier Java versions, we ran into this when an anonymous inner class captured a variable local to the method that surrounded it - we needed ...
Java Lambda Expressions
Lambda expressions are known to be the biggest feature introduced with Java 8. This was the Java's first step to Functional Programming. As most of us are used to write code using Object Oriented…
regex
As per Java Specification, lambda gets the variable values as final from the surrounding context as the lambda is passed to that context at runtime. The designer of the piece of code which accepts that lambda expression(or Functional Interface) accepts that interface instance\lambda with the faith that its values will not be altered.
Working with layers for Java Lambda functions
layer_content.zip └ java └ lib └ layer-java-layer-1.-SNAPSHOT.jar. The layer-java-layer-1.-SNAPSHOT.jar JAR file (an uber-jar that contains all of our required dependencies) is correctly located in the java/lib directory. This ensures that Lambda can locate the library during function invocations.
java
The simple answer is you cannot assign local variables from upper levels in lambda expressions. Either, you turn your variable into an instance member, or use an simple if statement:

Popular Tutorials

Java Flow Control

Java OOP (I)

Java OOP (II)

Java OOP (III)

Java Reader/Writer

Additional Topics

Java Tutorials

Java Lambda Expressions

Example 1: Define a Functional Interface in java

Example 2: Implement SAM with anonymous classes in java

Introduction to lambda expressions

How to define lambda expression in Java?

Example 4: Using lambda expression with parameters

Example 5: Generic Functional Interface and Lambda Expressions

Example 6: Demonstration of using lambdas with the Stream API

Table of Contents

Related Tutorials

Lambda Expressions

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

Target Typing

Java Tutorial

Using Lambda Expressions

COLOR PICKER

Contact Sales

Report Error

Top Tutorials

Java Lambda Expressions

Matching Lambdas to Interfaces

Java Lambdas and the Single Method Interface

Lambda Parameters

Variable Capture

Method References as Lambdas

Writing Your First Lambda Expression

Identifying the Type of a Lambda Expression

Examples of Functional Interfaces

Finding the Right Method to Implement

Implementing the Right Method with a Lambda Expression

Simplifying the Syntax

Implementing a Consumer<String>

Implementing a Runnable

Calling a Lambda Expression

Capturing Local Values

Serializing Lambdas

More Learning

Get started with lambda expressions in Java

Lambdas: A primer

Listing 1. LambdaDemo.java (version 1)

Listing 2. LambdaDemo.java (version 2)

Java lambdas in depth

Lambda syntax

Listing 3. LambdaDemo.java (version 3)

Target types

Listing 4. LambdaDemo.java (version 4)

Guide to Functional Interfaces and Lambda Expressions in Java

You might also like...

Improve your dev skills!

In this article

InfoQ Software Architects' Newsletter

Login with:

Choose your language

Lambdas in Java: An In-Depth Analysis

InfoQ Article Contest

Related Sponsored Content

Rate this Article

Related Editorial

Lambda Expressions

Functional Interfaces

Method Reference

Java Stream Programs

Java Stream Methods

Comparable and Comparator

Optional Class

Date/Time API

Java – Lambda Expression Variable Capturing with Examples

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

We Love Servers.

Java Lambda Expressions Explained: From Basics to Mastery