Functional Java

A functional interface declares exactly one abstract method, optionally marked @FunctionalInterface so the compiler enforces that. Because the single method is unambiguous, the interface can be the target type of a lambda or a method reference, which supplies its implementation. Examples are Runnable, Function, and Predicate.

A lambda such as (x) -> x * 2 is a concise inline implementation of a functional interface's single abstract method, with parameters on the left and a body on the right. As a closure it can capture local variables from the enclosing scope, but only effectively-final ones — variables never reassigned after initialization. It also sees enclosing fields and this.

Generics parameterize a type or method by a type argument such as <T>, so one definition works for many concrete types. They give compile-time type safety — the compiler rejects a wrong element type and inserts casts for you, so you write no manual casts. A bound like <T extends Number> constrains the argument to a type and its subtypes.

They are the four core shapes of java.util.function, told apart by what they take and what they return. Function<T,R> takes one argument and returns a result (apply). Supplier<T> takes nothing and produces a value (get). Consumer<T> takes a value and returns nothing, acting only by side effect (accept). Predicate<T> takes a value and returns a boolean (test). Two-argument and primitive variants such as BiFunction and IntPredicate follow the same pattern.

There are four: a static method (Integer::parseInt), an instance method of a particular object (out::println), an instance method of an arbitrary object of the type (String::length, where the receiver arrives as the first argument), and a constructor (ArrayList::new). Each one is shorthand for a lambda whose body does nothing but call that method, and it targets a functional interface exactly as the lambda would.

Optional<T> is a container that either holds a value or is empty, modeling a result that may be absent. It is meant to replace returning null, making absence explicit in the type and steering callers away from a NullPointerException. You access it with map, orElse, or ifPresent rather than unwrapping blindly with get, so the empty case is handled deliberately.

Calling get() without checking presence, which merely moves the NullPointerException one line down. Putting Optional on fields, parameters or collection elements, when it was designed for return types alone. Assigning null to an Optional variable instead of Optional.empty(). Writing isPresent() then get(), a null check in disguise — prefer map, filter or ifPresent. And using orElse for an expensive fallback, whose argument is evaluated even when a value is present.