Lambdas & Functional Interfaces

Lambda expressions, a cornerstone of Java 8, provide a clear and concise way to represent a single-method interface (a functional interface) using an expression. They allow you to treat functionality as a method argument, or code as data. A lambda expression can be thought of as an anonymous function. The basic syntax is `(parameters) -> { body; }`. For example, a lambda that takes two integers and returns their sum can be written as `(int a, int b) -> a + b;`. This is significantly more compact than creating an anonymous inner class. Lambdas are intrinsically linked to `functional interfaces`. A functional interface is any interface that contains exactly one abstract method. Examples from the JDK include `Runnable`, `Callable`, and `Comparator`. Java 8 also introduced a new package, `java.util.function`, which contains a set of common functional interfaces like `Predicate<T>` (takes a T, returns a boolean), `Function<T, R>` (takes a T, returns an R), and `Consumer<T>` (takes a T, returns nothing). A lambda expression can be assigned to a variable whose type is a functional interface, as long as the lambda's signature matches the signature of the interface's abstract method. This combination enables the functional programming paradigm in Java, allowing you to pass behaviors as arguments to methods, making your code more flexible and expressive, especially when used with the Streams API.