7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 1/22

Application Development

Framew ork

Application Express

Big Data

Business Intelligence

Cloud Computing

Communications

Database Performance &

Availability

Data Warehousing

Database

.NET

Dynamic Scripting Languages

Embedded

Digital Experience

Enterprise Architecture

Enterprise Management

Identity & Security

Java

Linux

Service-Oriented Architecture

Solaris

SQL & PL/SQL

Systems - All Articles

Virtualization

Trying Out Lambda Expressions in the Eclipse IDEby Deepak Vohra

Learn how to make the best of lambdas and virtual extension methods.

Published August 2013

Lambda expressions, also called closures, are a short-form replacement for anonymous classes. Lambda expressions simplify the use of

interfaces that declare a single abstract method, which are also called functional interfaces. In Java SE 7, a single method interface can be

implemented with one of the following options.

Create a class that implements the interface.Create an anonymous class.A lambda expression can be used to implement a functional interface without creating a class or an anonymous class. Lambda expressions can

be used only with interfaces that declare a single method.

Lambda expressions are designed to support a multicore processor architecture, which relies on software that provides parallelism, which in

turn, improves performance and reduces completion time.

Benefits of lambda expressions include the following:

Concise syntaxMethod references and constructor referencesReduced runtime overhead compared to anonymous classes

PrerequisitesTo follow along with the examples in this article, download and install the following software:

JDK 8Eclipse IDE with JDK 8 support

Syntax of Lambda ExpressionsThe syntax of a lambda expression is as follows.

(formal parameter list) ->{ expression or statements }

The parameter list is a comma-separated list of formal parameters that match the formal parameters of the single method in a functional

interface. Specifying the parameter types is optional; if the parameter types are not specified, the types are inferred from the context.

The parameter list must be enclosed in within parentheses except when a single parameter is specified without the parameter type; a single

formal parameter can be specified without parentheses. If a functional interface method does not specify any formal parameters, empty

parentheses must be specified.

The parameter list is followed by the -> operator, which is followed by the lambda body, which is a single expression or a statement block. The

lambda body has a result that must be one of the following:

void, if the functional interface method result is voidA Java type, primitive type, or reference type that is the same as the return type of the functional interface methodThe lambda body result is returned according to one of the following options:

If a single expression is used as the lambda body, the expression value is returned.If the method has a return type and the lambda body is not a single expression, the lambda body must return a value using a return statement.If the functional interface method result is void, a return statement can be provided, but that is not required.A statement block must be enclosed within curly braces ({}) unless the statement block is a method invocation statement for a method whose

result is void. The lambda body result must be the same as the result of the single method in the functional interface. For example, if the

functional interface method result is void, the lambda expression body must not return a value. If the functional interface method has a return type

of String, the lambda expression body must return a String. If the lambda body is a single statement and the method has a return type, the

statement must be a return statement. When a lambda expression is invoked, the code in the lambda body is run.

Functional InterfacesA lambda expression is used with a functional interface, which is an interface with essentially one abstract method; the interface can contain a

method that is also included in the Object class. Some examples of functional interfaces are java.util.concurrent.Callable—which has a

single method, call()—and java.lang.Runnable—which has a single method, run().

As a comparison, an anonymous class for an interface involves specifying an instance creation expression for the interface and the compiler

creating an instance of a class that implements the interface. Unlike an anonymous class, which specifies the interface type (or class type), a

lambda expression does not specify the interface type. The functional interface for which a lambda expression is invoked, also called the target

type of a lambda expression, is inferred from the context.

Target Type of a Lambda ExpressionA lambda expression has an implicit target type associated with it because an interface type is not explicitly specified. In a lambda expression, the

target type of a lambda conversion must be a functional interface. The target type is inferred from the context. Therefore, lambda expressions can

be used only in contexts in which the target type can be inferred. Such contexts are

A variable declarationAn assignmentA return statementAn array initializerMethod or constructor argumentsA lambda expression bodyA ternary conditional expression

Oracle Technology Network Articles Java

Products Solutions Downloads Store Support Training Partners About OTN

Sign In/Register Help Country Communities I am a... I want to... Search

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 2/22

A cast expression

Using the Eclipse IDE with Java SE 8 SupportTo use Java 8 in the Eclipse IDE, you need to download an Eclipse version that supports JDK 8.

In Eclipse, select Windows > Preferences and then select Java > Installed JREs. Install a JRE for JDK 8 using the JDK 8 you downloaded in the"Prerequisites" section.Select Java > Compiler and set Compiler compliance level to 1.8, as shown in Figure 1.

Figure 1

Click Apply and then OK.Select the JDK 1.8 JRE when creating a Java project in Eclipse.

Next, we discuss how lambda expressions can be used by looking at some examples.

The Hello Application with Lambda ExpressionsWe are familiar with the Hello application that outputs a message when supplied with a name. Class Hello declares two fields, two

constructors, and a hello() method to output a message, as shown below.

public class Hello { String firstname; String lastname; public Hello() {} public Hello(String firstname, String lastname) { this.firstname = firstname; this.lastname = lastname;} public void hello() { System.out.println("Hello " + firstname + " " + lastname);} public static void main(String[] args) { Hello hello = new Hello(args[0], args[1]); hello.hello(); }}

Now, we will see how lambda expressions simplify the syntax in the Hello example. First, we need to create a functional interface with a method

that returns a "Hello" message.

interface HelloService {String hello(String firstname, String lastname); }

Create a lambda expression with two parameters that match the parameters of the interface method. In the lambda expression body, create and

return a "Hello" message constructed from the firstname and lastname using a return statement. The return value must be the same type as

the return type of the interface method, and the target of the lambda expression must be the functional interface HelloService. See Listing 1.

public class Hello { interface HelloService { String hello(String firstname, String lastname); }

public static void main(String[] args) { HelloService helloService=(String firstname, String lastname) -> { String hello="Hello " + firstname + " " + lastname; return hello; };System.out.println(helloService.hello(args[0], args[1]));

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 3/22

}}Listing 1

Before we can run the Hello application, we need to provide some program arguments for the method arguments of hello(). Right-click

Hello.java in Package Explorer and select Run As > Run Configurations. In Run Configurations, select the Arguments tab, specify arguments

in the Program arguments field, and click Apply. Then click Close.

To run the Hello.java application, right-click Hello.java in Package Explorer and select Run As > Java Application. The application output is

displayed in the Eclipse console, as shown in Figure 2.

Figure 2

Local Variables in Lambda ExpressionsA lambda expression does not define a new scope; the lambda expression scope is the same as the enclosing scope. For example, if a lambda

expression body declares a local variable with the same name as a variable in the enclosing scope, a compiler error—Lambda expression's

local variable i cannot re-declare another local variable defined in an enclosing scope—gets generated, as shown in

Figure 3.

Figure 3

A local variable, whether declared in the lambda expression body or in the enclosing scope, must be initialized before being used. To

demonstrate this, declare a local variable in the enclosing method:

int i;

Use the local variable in the lambda expression. A compiler error—The local variable i may not have been initialized—gets

generated, as shown in Figure 4.

Figure 4

A variable used in a lambda expression is required to be final or effectively final. To demonstrate this, declare a local variable and initialize the

local variable:

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 4/22

int i=5;

Assign the variable in the lambda expression body. A compiler error—Variable i is required to be final or effectively final—

gets generated, as shown in Figure 5.

Figure 5

The variable i can be declared final as follows.

final int i=5;

Otherwise, the variable must be effectively final, which implies that the variable cannot be assigned in the lambda expression. Method parameter

variables and exception parameter variables from an enclosing context must also be final or effectively final.

The this and super references in a lambda body are the same as in the enclosing context, because a lambda expression does not introduce a

new scope, which is unlike the case with anonymous classes.

A Lambda Expression Is an Anonymous MethodA lambda expression is, in effect, an anonymous method implementation; formal parameters are specified and a value can be returned with a

return statement. The anonymous method must be compatible with the functional interface method it implements, as dictated by the following

rules.

The lambda expression must return a result that is compatible with the result of the functional interface method. If the result is void, the lambdabody is void-compatible. If a value is returned, the lambda body is value-compatible. The return value can be of a type that is a subtype of thereturn type in the functional interface method declaration.The lambda expression signature must be the same as the functional interface method's signature. The lambda expression signature cannot bea subsignature of the functional interface method's signature.The lambda expression can throw only those exceptions for which an exception type or an exception supertype is declared in the functionalinterface method's throws clause.To demonstrate that a lambda expression must return a result if the functional interface method returns a result, comment out the return

statement in the lambda expression that has the target type HelloService. Because the hello() method in the functional interface,

HelloService, has a return type of String, a compiler error is generated, as shown in Figure 6.

Figure 6

If the functional interface method declares the result as void and the lambda expression returns a value, a compiler error is generated, as shown

in Figure 7.

Figure 7

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 5/22

If the lambda expression signature is not exactly the same as the functional interface method signature, a compiler error is generated. To

demonstrate this, make the lambda expression parameter list empty while the functional interface method declares two formal parameters. A

compiler error—Lambda expression's signature does not match the signature of the functional interface method—is

generated, as shown in Figure 8.

Figure 8

No distinction is made between a vararg parameter and its array equivalent. For example, a functional interface method declares an array-type

parameter as follows:

interface Int { void setInt(int[] i);

}

The parameter list of the lambda expression can declare a vararg parameter:

Int int1 =(int... i)->{};

Exception HandlingA lambda expression body must not throw more exceptions than specified in the throws clause of the functional interface method. If a lambda

expression body throws an exception, the throws clause of the functional interface method must declare the same exception type or its

supertype.

To demonstrate this, do not declare a throws clause in the hello method of the HelloService interface and throw an exception from the

lambda expression body. A compiler error message—Unhandled exception type Exception—is generated, as shown in Figure 9.

Figure 9

If the same exception type as the thrown exception is added to the functional interface method, the compiler error is resolved, as shown in Figure

10. But, a compiler error message is generated if the hello method is invoked using the reference variable to which the lambda expression

result is assigned, because the exception is not handled in the main method, which is also shown in Figure 10.

Figure 10

A Lambda Expression Is a Poly Expression

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 6/22

The type of a lambda expression is a deduced type, and the type is deduced from the target type. The same lambda expression could have

different types in different contexts. Such an expression is called a poly expression. To demonstrate this, define another functional interface that

has the same abstract method signature as HelloService, for example:

interface HelloService2 { String hello(String firstname, String lastname);

}

The same lambda expression, for example, the following expression, can be used with the two functional interfaces that declare a method that

has the same signature, return type, and throws clause:

(String firstname, String lastname) -> { String hello = "Hello " + firstname + " " + lastname; return hello; }

Without a context, the preceding lambda expression does not have a type, because it does not have a target type. But, if it is used in the context of

a target type, the lambda expression could have different types based on the target type. In the following two contexts, the preceding lambda

expression has different types because the target types are different: HelloService and HelloService2.

HelloService helloService =(String firstname, String lastname) -> { String hello = "Hello " + firstname + " " + lastname; return hello; };

HelloService2 helloService2 =(String firstname, String lastname) -> { String hello = "Hello " + firstname + " " + lastname; return hello; };

Generic lambdas are not supported. A lambda expression cannot introduce type variables.

Lambda Expressions in a GUI ApplicationGUI components in the java.awt package make use of the java.awt.event.ActionListener interface to register action events from a

component. The java.awt.event.ActionListener interface is a functional interface with only one method: actionPerformed(ActionEvent

e).

A java.awt.event.ActionListener is registered with a component using the addActionListener(ActionListener l) method. For

example, a java.awt.event.ActionListener could be registered with a java.awt.Button component using an anonymous inner class in

the application to count the number of times a Button object called b has been clicked, as follows. (See "How to Write an Action Listener" for

more details.)

b.addActionListener (new ActionListener() { int numClicks = 0; public void actionPerformed(ActionEvent e) { numClicks++; text.setText("Button Clicked " + numClicks + " times"); } });

A lambda expression can be used instead of the anonymous inner class to make the syntax more concise. The following is an example of using

a lambda expression to register an ActionListener with a Button component:

b.addActionListener(e -> { numClicks++; text.setText("Button Clicked " + numClicks + " times"); });

}

The parentheses for specifying the parameter can be omitted for a single-parameter lambda expression. The target type of the lambda

expression—the functional interface ActionListener—is inferred from the context, which is a method invocation.

Using Lambda Expressions with Some Common Functional InterfacesIn this section, we will discuss how some common functional interfaces can be used with lambda expressions.

The FileFilter InterfaceThe FileFilter interface has a single method, accept(), and is used to filter files. In The Java Tutorials ImageFilter example, the

ImageFilter class implements the FileFilter interface and provides implementation for the accept() method. The accept() method is

used to accept just the image files (and directories) using a Utils class.

We could use a lambda expression that returns a boolean to provide implementation for the FileFilter interface, as shown in Listing 2.

import java.io.FileFilter;import java.io.File;

public class ImageFilter {

public static void main(String[] args) { FileFilter fileFilter = (f) -> { String extension = null; String s = f.getName(); int i = s.lastIndexOf('.');

if (i > 0 && i << s.length() - 1) { extension = s.substring(i + 1).toLowerCase(); } if (extension != null) {

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 7/22

if (extension.equals("tiff") || extension.equals("tif") || extension.equals("gif") || extension.equals("jpeg") || extension.equals("jpg") || extension.equals("png") || extension.equals("bmp")) { return true; } else { return false; } } return false; };

File file = new File("C:/JDK8/Figure10.bmp"); System.out.println("File is an image file: " + fileFilter.accept(file));

}}Listing 2

The output from the ImageFilter class is shown in the Eclipse console in Figure 11.

Figure 11

The Runnable InterfaceIn The Java Tutorials "Defining and Starting a Thread" section, the HelloRunnable class implements the Runnable interface, and a Thread is

created using an instance of the HelloRunnable class. A Runnable for the Thread can be created using a lambda expression, as shown in

Listing 3. The lambda expression does not have a return statement, because the method run() in Runnable has result as void.

import java.lang.Runnable;

public class HelloRunnable {

public static void main(String args[]) { (new Thread(() -> { System.out.println("Hello from a thread"); })).start(); }}

Listing 3The output from the HelloRunnable class is shown in Figure 12.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 8/22

Figure 12

The Callable InterfaceIf we created a class that implements the java.util.concurrent.Callable<V> generic functional interface, the class would need to

implement the call() method. In Listing 4, class HelloCallable implements the parameterized type Callable<String>.

package lambda;

import java.util.concurrent.Callable;

public class HelloCallable implements Callable<String> { @Override public String call() throws Exception {

return "Hello from Callable"; }

public static void main(String[] args) { try { HelloCallable helloCallable = new HelloCallable(); System.out.println(helloCallable.call()); } catch (Exception e) { System.err.println(e.getMessage()); } }}Listing 4

We can use a lambda expression to provide implementation for the call() generic method. Because the call() method does not take any

parameters, the parentheses in the lambda expression are empty and, because the method returns a String for the parameterized type

Callable<String>, the lambda expression must return a String.

import java.util.concurrent.Callable;

public class HelloCallable {

public static void main(String[] args) { try {

Callable<String> c = () -> "Hello from Callable"; System.out.println(c.call()); } catch (Exception e) { System.err.println(e.getMessage()); } }}Listing 5

The output from HelloCallable is shown in Figure 13.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 9/22

Figure 13

The PathMatcher InterfaceThe java.nio.file.PathMatcher interface is used to match paths. The functional interface has a single method, matches(Path path), that

is used to match a Path. We can use a lambda expression to provide the implementation for the matches() method, as shown in Listing 6. The

lambda expression returns a boolean and the target type is the functional interface PathMatcher.

import java.nio.file.PathMatcher;import java.nio.file.Path;import java.nio.file.FileSystems;

public class FileMatcher {

public static void main(String[] args) {

PathMatcher matcher = (f) -> { boolean fileMatch = false; String path = f.toString(); if (path.endsWith("HelloCallable.java")) fileMatch = true; return fileMatch; }; Path filename = FileSystems.getDefault().getPath( "C:/JDK8/HelloCallable.java"); System.out.println("Path matches: " + matcher.matches(filename));

}}Listing 6

The output from the FileMatcher class is shown in Figure 14.

Figure 14

The Comparator InterfaceThe functional interface Comparator has a single method: compares(). The interface also has the equals() method, but the equals() method

is also in the Object class. A functional interface can have Object class methods in addition to one other method. If we were to compare

instances of an Employee entity using Comparator, we would first define the Employee POJO, which has properties and getter/setters for empId,

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 10/22

firstName, and lastName, as shown in Listing 7.

import java.util.*;

public class Employee {

private int empId; private String lastName; private String firstName;

public Employee() { }

public Employee(int empId, String lastName, String firstName) { this.empId = empId; this.firstName = firstName; this.lastName = lastName;

}

// setters and getters public int getEmpId() { return empId; }

public void setEmpId(int empId) { this.empId = empId; }

public String getLastName() { return lastName; }

public void setLastName(String lastName) { this.lastName = lastName; }

public String getFirstName() { return firstName; }

public void setFirstName(String firstName) { this.firstName = firstName; }

public int compareByLastName(Employee x, Employee y) { return x.getLastName().compareTo(y.getLastName()); }

/** * * public static int compareByLastName(Employee x, Employee y) { return x.getLastName().compareTo(y.getLastName()); } */}Listing 7

As shown in Listing 8, create a class called EmployeeSort to sort a List of Employee entities based on lastName. In the EmployeeSort class,

create a List object and add Employee objects to it. Use the Collections.sort method to sort the List and create a Comparator object for

the sort() method using an anonymous inner class.

package lambda;

import java.util.*;

public class EmployeeSort {

public static void main(String[] args) {

Employee e1 = new Employee(1, "Smith", "John"); Employee e2 = new Employee(2, "Bloggs", "Joe"); List<Employee> list = new ArrayList<Employee>(); list.add(e1); list.add(e2);

Collections.sort(list, new Comparator<Employee>() { public int compare(Employee x, Employee y) { return x.getLastName().compareTo(y.getLastName()); } }); ListIterator<Employee> litr = list.listIterator();

while (litr.hasNext()) { Employee element = litr.next();

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 11/22

System.out.print(element.getLastName() + " "); }

}}Listing 8

The anonymous inner class can be replaced with a lambda expression that takes two Employee-type parameters and returns an int value

based on the lastName comparison, as shown in Listing 9.

import java.util.*;

public class EmployeeSort {

public static void main(String[] args) {

Employee e1 = new Employee(1, "Smith", "John"); Employee e2 = new Employee(2, "Bloggs", "Joe"); List<Employee> list = new ArrayList<Employee>(); list.add(e1); list.add(e2);

Collections.sort(list, (x, y) -> x.getLastName().compareTo(y.getLastName()));

ListIterator<Employee> litr = list.listIterator();

while (litr.hasNext()) { Employee element = litr.next(); System.out.print(element.getLastName() + " "); }

}}Listing 9

The output from EmployeeSort is shown in Figure 15.

Figure 15

How Are the Target Type and Lambda Parameter Type Inferred?For lambda expressions, the target type is inferred from the context. A lambda expression can be used only in contexts in which the target type can

be inferred. Such contexts are a variable declaration, an assignment statement, a return statement, an array initializer, method or constructor

arguments, a lambda expression body, a conditional expression, and a cast expression.

The lambda formal parameters types are also inferred from the context. In all the preceding examples except the Hello example in Listing 1, the

parameter types are inferred from the context. In subsequent sections, we discuss some of the contexts in which the lambda expressions could

be used.

Lambda Expressions in return StatementsA lambda expression can be used in a return statement. The return type of the method in which a lambda expression is used in a return

statement must be a functional interface. For example, include a lambda expression in a return statement for a method that returns a Runnable,

as shown in Listing 10.

import java.lang.Runnable;

public class HelloRunnable2 {

public static Runnable getRunnable() { return () -> { System.out.println("Hello from a thread"); };

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 12/22

}

public static void main(String args[]) {

new Thread(getRunnable()).start(); }

}Listing 10

The lambda expression does not declare any parameters, because the run() method of the Runnable interface does not declare any formal

parameters. The lambda expression does not return a value, because the run() method has the result as void. The output from Listing 10 is

shown in Figure 16.

Figure 16

Lambda Expressions as Target TypesLambda expressions themselves can be used as target types for inner lambda expressions. The call() method in Callable returns an

Object, but the run() method in Runnable doesn't have a return type. The target type of the inner lambda expression in the HelloCallable2

class is a Runnable, and the target type of the outer lambda expression is Callable. The target type is inferred from the context, which is an

assignment statement to a reference variable of type Callable<Runnable>.

In Listing 11, the inner lambda expression, () -> {System.out.println("Hello from Callable");}, is inferred to be of type Runnable

because the parameter list is empty and the result is void; the anonymous method signature and result are the same as the run() method in

the Runnable interface. The outer lambda expression, () -> Runnable, is inferred to be of type Callable<Runnable> because the call()

method in Callable<V> does not declare any formal parameters and the result type is type parameter V.

import java.util.concurrent.Callable;

public class HelloCallable2 {

public static void main(String[] args) { try {

Callable<Runnable> c = () -> () -> { System.out.println("Hello from Callable"); }; c.call().run();

} catch (Exception e) { System.err.println(e.getMessage()); } }}Listing 11

The output from HelloCallable2 is shown in Figure 17.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 13/22

Figure 17

Lambda Expressions in Array InitializersLambda expressions can be used in array initializers, but generic array initializers cannot be used. For example, lambda expressions in the

following generic array initializer would generate a compiler error:

Callable<String>[] c=new Callable<String>[]{ ()->"a", ()->"b", ()->"c" };

A compiler error—Cannot create a generic array of Callable<String>—gets generated, as shown in Figure 18.

Figure 18

To use lambda expressions in an array initializer, specify a non-generic array initializer, as in the CallableArray class shown in Listing 12.

import java.util.concurrent.Callable;

public class CallableArray {

public static void main(String[] args) {try{

Callable<String>[] c=new Callable[]{ ()->"Hello from Callable a", ()->"Hello from Callable b", ()->"Hello from Callable c" };

System.out.println(c[1].call());}catch(Exception e){System.err.println(e.getMessage());}}}

Listing 12Each of the array initializer variables in CallableArray is a lambda expression of type Callable<String>. The parameter list of the lambda

expression is empty and the result of the lambda expression is a single expression that evaluates to a String. The target type of each of the

lambda expressions is inferred to be of type Callable<String> from the context. The output from CallableArray is shown in Figure 19.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 14/22

Figure 19

Casting Lambda ExpressionsSometimes the target type of a lambda expression can be ambiguous. For example, in the following assignment statement, a lambda expression

is used as a method argument to the AccessController.doPrivileged method. The target type of the lambda expression is ambiguous

because more than one functional interface—PrivilegedAction and PrivilegedExceptionAction—could be the target type of the lambda

expression.

String user = AccessController.doPrivileged(() -> System.getProperty("user.name"));

A compiler error—The method doPrivileged(PrivilegedAction<String>) is ambiguous for the type AccessController—gets

generated, as shown in Figure 20.

Figure 20

We can use a cast to the lambda expression to specify the target type as PrivilegedAction<String>, as in the UserPermissions class

shown in Listing 13.

import java.security.AccessController;import java.security.PrivilegedAction;

public class UserPermissions {

public static void main(String[] args) {

String user = AccessController .doPrivileged((PrivilegedAction<String>) () -> System .getProperty("user.name")); System.out.println(user);

}}Listing 13

The output from UserPermissions with a cast in the lambda expression is shown in Figure 21.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 15/22

Figure 21

Lambda Expressions in Conditional ExpressionsLambda expressions can be used in ternary conditional expressions, which evaluate one of the two operands based on whether a boolean

condition is true or false.

In the HelloCallableConditional class shown in Listing 14, the lambda expressions—() -> "Hello from Callable: flag true") and

() -> "Hello from Callable: flag false")—constitute the two alternative expressions to evaluate. The target type of the lambda

expressions is inferred from the context, which is an assignment statement to a Callable<String> reference variable. Subsequently, the

reference variable is used to invoke the call() method.

import java.util.concurrent.Callable

public class HelloCallableConditional {

public static void main(String[] args) { try {

boolean flag = true; Callable<String> c = flag ? (() -> "Hello from Callable: flag true") : (() -> "Hello from Callable: flag false");

System.out.println(c.call()); } catch (Exception e) { System.err.println(e.getMessage()); } }}Listing 14

The output from HelloCallableConditional is shown in Figure 22.

Figure 22

Inferring the Target Type in Overloaded MethodsWhen you invoke a method that is overloaded, the method that best matches the lambda expression is used. The target type and the method

argument type are used to resolve the best method.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 16/22

In the HelloRunnableOrCallable class in Listing 15, two hello() methods (the hello() method is overloaded) with return type String are

specified: one with parameter type Callable and the other with parameter type Runnable.

The hello() method is invoked with a lambda expression as a method argument. Because the lambda expression—() -> "Hello

Lambda"—returns a String, the hello(Callable) method is invoked, and Hello from Callable is output because the call() method of

Callable has a return type, whereas the run() method of Runnable doesn't.

import java.util.concurrent.Callable;

public class HelloRunnableOrCallable {

static String hello(Runnable r) { return "Hello from Runnable"; }

static String hello(Callable c) { return "Hello from Callable"; }

public static void main(String[] args) {

String hello = hello(() -> "Hello Lambda"); System.out.println(hello);

}}Listing 15

The output from HelloCallableConditional is shown in Figure 23.

Figure 23

this in Lambda ExpressionsOutside a lambda expression, this refers to the current object. In a lambda expression also, this refers to the enclosing current object. Lambda

expressions that do not refer to members of the enclosing instance do not store a strong reference to it, which solves a memory leak problem that

often occurs in inner class instances that hold a strong reference to the enclosing class.

In the example in Listing 16, Runnable is the target type of a lambda expression. In the lambda expression body, a reference to this is specified.

When an instance of Runnable r is created and the run() method is invoked, the this reference invokes the enclosing instance and a String

value of the enclosing instance is obtained from the toString() method. The message Hello from Class HelloLambda gets output.

public class HelloLambda { Runnable r = () -> { System.out.println(this); };

public String toString() { return "Hello from Class HelloLambda"; }

public static void main(String args[]) { new HelloLambda().r.run(); } }Listing 16

The output from HelloLambda is shown in Figure 24.

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 17/22

Figure 24

Lambda Expression Parameter NamesNew names are created for the formal parameters of a lambda expression. If the same names as the local variable names in the enclosing

context are used as lambda expression parameter names, a compiler error gets generated. In the following example, lambda expression

parameter names are specified as e1 and e2, which are also used for local variables Employee e1 and Employee e2.

Employee e1 = new Employee(1,"A", "C"); Employee e2 = new Employee(2,"B","D" ); List<Employee> list = new ArrayList<Employee>(); list.add(e1);list.add(e2);

Collections.sort(list, (Employee e1, Employee e2) -> e1.getLastName().compareTo(e2.getLastName()));

A compiler error is generated for lambda expression parameter e1, as shown in Figure 25.

Figure 25

A compiler error is also generated for lambda expression parameter e2, as shown in Figure 26.

Figure 26

References to Local VariablesIn providing an alternative to anonymous inner classes, the requirement for local variables to be final in order to be accessed in a lambda

expression was removed. The requirement for a local variable to be final to be accessed from an inner class is also removed in JDK 8. In JDK 7,

a local variable accessed from an inner class must be declared final.

The requirement for a local variable to be used in an inner class or a lambda expression has been modified from "final" to "final or effectively

final."

Method ReferencesA lambda expression defines an anonymous method with a functional interface as the target type. Instead of defining an anonymous method,

existing methods with a name can be invoked using method references. In the EmployeeSort example in Listing 9, the following method

invocation has a lambda expression as a method argument.

Collections.sort(list, (x, y) -> x.getLastName().compareTo(y.getLastName()));

The lambda expression can be replaced with a method references as follows:

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 18/22

Collections.sort(list, Employee::compareByLastName);

The delimiter (::) can be used for a method reference. The method compareByLastName is a static method in the Employee class.

public static int compareByLastName(Employee x, Employee y) { return x.getLastName().compareTo(y.getLastName());

For non-static methods, method references can be used with instances of a particular object. By making the compareByLastName method non-

static, a method reference with an Employee instance can be used as follows:

Employee employee=new Employee();Collections.sort(list, employee::compareByLastName);

The method reference doesn't even have to be an instance method of the object in which it is used. The method reference can be an instance

method of any arbitrary class object. For example, a String List can be sorted using the compareTo method from the String class with a

method reference:

String e1 = new String("A"); String e2 = new String("B"); List<String> list = new ArrayList<String>(); list.add(e1);list.add(e2);Collections.sort(list, String::compareTo);

Method references are a further simplification of lambda expressions.

Constructor ReferencesMethod references are used for method invocations, and constructor references are used with constructor invocations. Method references and

constructor references are lambda conversions, and the target type of method references and constructor references must be a functional

interface.

In this section, we discuss constructor references using a Multimap as an example. Multimap is a Google Collections utility. A Multimap for

image types is created as follows:

Multimap<ImageTypeEnum, String> imageTypeMultiMap = Multimaps .newListMultimap( Maps.<ImageTypeEnum, Collection<String>> newHashMap(), new Supplier<List<String>>() { public List<String> get() { return new ArrayList<String>(); } });

In the Multimap example, a Supplier<List<String>> is created using a constructor as follows:

new Supplier<List<String>>() { public List<String> get() { return new ArrayList<String>(); } }

The constructor returns an ArrayList<String>. Using a constructor reference, the Multimap can be created with a simplified syntax as follows:

Multimap<ImageTypeEnum, String> imageTypeMultiMap = Multimaps.newListMultimap(Maps.<ImageTypeEnum, Collection<String>> newHashMap(),ArrayList<String>::new);

The Multimap example ImageTypeMultiMap class with constructor reference is shown in Listing 17.

import java.util.ArrayList;import java.util.Collection;import java.util.List;

import com.google.common.base.Supplier;import com.google.common.collect.Maps;import com.google.common.collect.Multimap;import com.google.common.collect.Multimaps;

public class ImageTypeMultiMap { enum ImageTypeEnum { tiff, tif, gif, jpeg, jpg, png, bmp }

public static void main(String[] args) { Multimap<ImageTypeEnum, String> imageTypeMultiMap = Multimaps .newListMultimap( Maps.<ImageTypeEnum, Collection<String>> newHashMap(), ArrayList<String>::new);

imageTypeMultiMap.put(ImageTypeEnum.tiff, "tiff"); imageTypeMultiMap.put(ImageTypeEnum.tif, "tif"); imageTypeMultiMap.put(ImageTypeEnum.gif, "gif"); imageTypeMultiMap.put(ImageTypeEnum.jpeg, "jpeg"); imageTypeMultiMap.put(ImageTypeEnum.jpg, "jpg"); imageTypeMultiMap.put(ImageTypeEnum.png, "png"); imageTypeMultiMap.put(ImageTypeEnum.bmp, "bmp");

System.out.println("Result: " + imageTypeMultiMap); }}Listing 17

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 19/22

To test the ImageTypeMultiMap class, we need to download the Guava library guava-14.0.1.jar from https://code.google.com/p/guava-

libraries/ and add the guava-14.0.1.jar to the Java build path. The output from ImageTypeMultiMap is shown in Figure 27.

Figure 27

Virtual Extension MethodsEncapsulation and reusability of an interface are the main benefits of an interface. But an interface has a disadvantage in that that all the interface

methods must be implemented in a class that implements an interface. Sometimes only a few of the methods are required from an interface, but

method implementations for all the interface methods must be provided when the interface is implemented. Virtual extension methods provide a

fix for the issue.

Virtual extension methods are the methods in an interface that have a default implementation. If an implementing class does not provide an

implementation for the method, the default implementation is used. An implementing class can override the default implementation or provide a

new default implementation.

Virtual extension methods add the provision to expand the functionality of interfaces without breaking backward compatibility of classes that are

already implementing an earlier version of the interface. The default implementation in a virtual extension method is provided using the default

keyword. A virtual extension method provides a default implementation and, therefore, cannot be abstract.

The java.util.Map<K,V> class in JDK 8 provides several methods that have default implementations:

default V getOrDefault(Object key,V defaultValue)default void forEach(BiConsumer<? super K,? super V> action)default void replaceAll(BiFunction<? super K,? super V,? extends V> function)default V putIfAbsent(K key,V value)default boolean remove(Object key,Object value)default boolean replace(K key,V oldValue,V newValue)default V replace(K key,V value)default V computeIfAbsent(K key,Function<? super K,? extends V> mappingFunction)default V computeIfPresent(K key,BiFunction<? super K,? super V,? extends V> remappingFunction)default V compute(K key,BiFunction<? super K,? super V,? extends V> remappingFunction)default V merge(K key,V value,BiFunction<? super V,? super V,? extends V> remappingFunction)To demonstrate that methods with default implementation do not need to be implemented when an interface is implemented by a class, create a

class called MapImpl that implements the Map<K,V> interface:

public class MapImpl<K,V> implements Map<K, V> {

}The complete MapImpl class with implementation for the methods that do not provide a default implementation is shown in Listing 18.

import java.util.Collection;import java.util.Map;import java.util.Set;

public class MapImpl<K,V> implements Map<K, V> {

public static void main(String[] args) {

}

@Override public int size() { return 0; }

@Override public boolean isEmpty() { return false; }

@Override

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 20/22

public boolean containsKey(Object key) {

return false; }

@Override public boolean containsValue(Object value) { return false; }

@Override public V get(Object key) {

return null; }

@Override public V put(K key, V value) {

return null; }

@Override public V remove(Object key) {

return null; }

@Override public void putAll(Map<? extends K, ? extends V> m) {

}

@Override public void clear() {

}

@Override public Set<K> keySet() {

return null; }

@Override public Collection<V> values() {

return null; }

@Override public Set<java.util.Map.Entry<K, V>> entrySet() {

return null; }

}Listing 18

The Map<K,V> interface is a predefined interface, but a new interface with virtual extension methods can also be defined. Create an interface

called EmployeeDefault with default implementations for all the methods using the default keyword, as shown in Listing 19.

public interface EmployeeDefault {

String name = "John Smith"; String title = "PHP Developer"; String dept = "PHP";

default void setName(String name) { System.out.println(name); }

default String getName() { return name; }

default void setTitle(String title) { System.out.println(title); }

default String getTitle() { return title; }

default void setDept(String dept) { System.out.println(dept); }

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 21/22

default String getDept() { return dept; }}Listing 19

If an interface method is declared with the default keyword, the method must provide an implementation, as indicated by the compiler error

shown in Figure 28.

Figure 28

The fields of an interface are final by default and cannot be assigned in the default implementation of a default method, as indicated by the

compiler error shown in Figure 29.

Figure 29

A class that implements the interface EmployeeDefault is not required to provide an implementation for the virtual extension methods. The

EmployeeDefaultImpl class implements the EmployeeDefault interface and does not provide an implementation for any of the virtual

extension methods inherited from EmployeeDefault. The EmployeeDefaultImpl class invokes the virtual extension methods using method

invocation expressions, as shown in Listing 20.

public class EmployeeDefaultImpl implements EmployeeDefault {

public static void main(String[] args) { EmployeeDefaultImpl employeeDefaultImpl=new EmployeeDefaultImpl(); System.out.println(employeeDefaultImpl.getName()); System.out.println(employeeDefaultImpl.getTitle()); System.out.println(employeeDefaultImpl.getDept());

}

}Listing 20

ConclusionThis article introduced a new feature in JDK 8 called lambda expressions, which provide a concise syntax and a short-form replacement for

anonymous classes. It also described virtual extension methods, which are beneficial because they provide interfaces with a default method

implementation, which is used if an implementing class does not provide an implementation for a method.

See AlsoLambda Expressions

About the AuthorDeepak Vohra is a NuBean consultant, web developer, Sun Certified Java 1.4 Programmer, and Sun Certified Web Component Developer for

Java EE.

Join the ConversationJoin the Java community conversation on Facebook, Twitter, and the Oracle Java Blog!

E-mail this page Printer View

ORACLE CLOUD

Learn About Oracle Cloud

JAVA

Learn About Java

CUSTOMERS AND EVENTS

Explore and Read Customer

COMMUNITIES

Blogs

SERVICES AND STORE

Log In to My Oracle Support

7/18/2014 Trying Out Lambda Expressions in the Eclipse IDE

http://www.oracle.com/technetwork/articles/java/lambda-1984522.html 22/22

Computing

Get a Free Trial

Learn About PaaS

Learn About SaaS

Learn About IaaS

Learn About Private Cloud

Learn About Managed Cloud

Download Java forConsumers

Download Java for Developers

Java Resources forDevelopers

Java Cloud Service

Java Magazine

Stories

All Oracle Events

Oracle OpenWorld

JavaOne

Discussion Forums

Wikis

Oracle ACEs

User Groups

Social Media Channels

Training and Certification

Become a Partner

Find a Partner Solution

Purchase from the OracleStore

CONTACT AND CHAT

Phone: +1.800.633.0738 Global ContactsOracle SupportPartner Support

Subscribe Careers Contact Us Site Maps Legal Notices Terms of Use Privacy Cookie Preferences Oracle Mobile