Understanding Java Lambda Expressions and Functional Interfaces

Lambda expressions were introduced in Java 8 to enable functional programming by allowing functions to be created without belonging to a class and passed around like objects.

They are commonly used to implement single-method (functional) interfaces, especially when working with the Java Streams API for operations such as filtering collections.

Example of a Stream filter using a lambda:

List<A> list = aList.filter(a -> a.getId() > 10).collect(Collectors.toList);

The lambda a -> a.getId() > 10 matches the filter method's expected functional interface.

Functional interfaces have exactly one abstract method. To match a lambda to an interface, three rules must be satisfied: the interface must be functional, the lambda's parameters must match the abstract method's parameters, and the lambda's return type must match the method's return type.

Even interfaces with default or static methods can be implemented by lambdas as long as they contain only one abstract method.

Compared with anonymous classes, lambdas are more concise and cannot have their own state; they capture local, instance, and static variables from the surrounding context.

Lambda parameter forms include zero‑parameter () -> … , single‑parameter param -> … (parentheses optional), and multi‑parameter (p1, p2) -> … . Types can be omitted when inferred, otherwise they must be specified.

The lambda body follows the -> operator; a single expression can be used directly, while multiple statements require braces and an explicit return if a value is needed.

Method references provide a shorter syntax when a lambda merely forwards its arguments to an existing method. Forms include references to static methods ( ClassName::staticMethod ), instance methods of a particular object ( instance::method ), instance methods of an arbitrary object of a type ( ClassName::instanceMethod ), and constructors ( ClassName::new ).

Examples:

MyPrinter myPrinter = System.out::println;

Finder finder = MyClass::doFind;

Deserializer des = stringConverter::convertToInt;

Factory factory = String::new;

Understanding these concepts lays the foundation for more advanced Stream operations and the use of built‑in functional interfaces in Java.

In summary, the article consolidates knowledge about lambda expressions, functional interfaces, variable capture, and method references, preparing readers for deeper functional programming in Java.