Java 8 Lambda Expressions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search

External

Internal

Overview

Java 8 introduces functional programming features, in the form of lambda expressions. Lambda expressions allow behavior parameterization - functions can be now assigned to variables, as values, and passed around, which essentially means passing code around. Functions come in form of lambda expressions (anonymous functions) or method references.

Lambda Expression

A lambda expression is a representation of an anonymous function: it does not have a name, but it has a list of parameters, a body, a return type, and possibly a list of exceptions that can be thrown.

Lambda expressions can be stored as values, in variables, and passed as arguments to methods and constructors. In all these cases, the type of the lambda expression value is a functional interface.

Semantically, lambda expressions do not allow programmers to do anything that couldn't have been done before their introduction in Java 8, via anonymous classes. However, the lambda syntax is more concise, lambda expressions are a convenient way of increasing the code clarity by in-lining logic. If the lambda's body exceeds a few lines in length, so that its behavior isn't instantly clear, the logic should be encapsulated in a method and a method reference should be used instead of the lambda expression.

The term lambda comes from a system developed in academia called lambda calculus, which is used to describe computations.

Syntax

(parameter-list) -> body

The most generic format of the parameter-list is:

Type1 var1, Type2 var2, ...

The parameter list could be empty:

() -> ...

"->" is referred to as "arrow".

The body can be a single expression, and it this case the lambda is known as an "expression-style lambda", or a list of statements included enclosed in curly braces - a block - and in this case the lambda is known as "block-style lambda".

Block-Style Lambda

(parameter-list) -> { statement1; statement2; ... }

The absence of a return as the last statement in the block implies that the lambda returns void:

(Apple a) -> { 
    System.out.println("the apple is " + a.getColor());
    System.out.println("the apple weighs " + a.getWeight() + " grams");
};

This lambda, that has no parameters and returns void, is valid:

() -> {}

If the lambda execution returns a value, the last statement in the block must be return:

(Apple a) -> { 
    boolean heavy = a.getWeight() > 100; 
    return a.getColor() + "(" + (heavy ? "heavy":"light") + ")"; 
};

Expression-Style Lambda

(parameter-list) -> expression

If the lambda is supposed to return a value, then the value the expression evaluates to is returned as value of lambda execution.

(Apple a) -> a.getColor() + " (" + a.getWeight() + " grams)";

If the lambda is supposed to return void, the value the expression evaluates to is discarded.

Method Reference

The semantics behind the method reference syntax is use this method as a value.

The <Class-Name>::<method-name> syntax creates a method reference, which then can be passed around as a value.

Relationship between Lambda Expressions and Method References

Functional Interface

A lambda value type is given by a functional interface: lambda values can be used and passed around everywhere a functional interface is expected.

@FunctionalInterface

Predicate

A predicate is a function that evaluates an argument and returns a boolean.

https://github.com/NovaOrdis/playground/tree/master/java/java8/lambda-expressions/02-predicate









To Process

A lambda expression can be thought of as an anonymous methods. As shown in the "Syntax" section below, a lambda expression looks a lot like a method declaration.

Playground Example

https://github.com/NovaOrdis/playground/blob/master/java/java8/lambda-expression/src/main/java/io/novaordis/playground/java/java8/lambda/Main.java

Functional Interface

An interface with only one method is named functional interface

Apparently this is the type of a lambda expression, it describe the function signature.

The Type of a Lambda Expression

Elaborate here.

Syntax

A lambda expression consists in a comma-separated list of formal parameters, enclosed in parentheses, followed by the arrow token "->" followed by a body, which may be a single expression or a statement block.

(comma_separated_formal_parameter_list) -> body

Formal Parameters

The type of the parameters may be omitted.

If there is a single parameter, the enclosed parentheses may be omitted.

Body

The body may be a single expression, or a statement block.

Referencing a Lambda Expression

Method References

Example:

    public ZipHandler getZipHandler() {

        return ZipUtil::getTopLevelDirectoryName;
    }

Variables

The variables used in the lambda expressions must be final.


TODO