Functional Interfaces

A functional interface has exactly one abstract method (SAM), can have unlimited default and static methods, and is the target type for lambda expressions and method references.

@FunctionalInterface is optional but strongly recommended as a compile-time guard; any SAM interface works as a lambda target, can extend other interfaces, and can have unlimited default and static methods.

Predicate filters (T to boolean), Function transforms (T to R), Consumer acts (T to void), Supplier creates (nothing to T): these four plus BiFunction, UnaryOperator, and BinaryOperator cover all lambda shapes.

BiConsumer, BiPredicate, and BiFunction are two-argument versions of the core functional interfaces, used primarily with Map operations like forEach, merge, and compute.

UnaryOperator<T> extends Function<T,T> for same-type transformations, and BinaryOperator<T> extends BiFunction<T,T,T> for same-type reductions.

Predicate.not() cleanly negates a method reference for stream filtering, and Pattern.asPredicate/asMatchPredicate convert regex patterns to Predicates for find/matches checks.

highSalary.and(inIT) is true only when both predicates pass, with short-circuit evaluation.

logDetails.andThen(sendAlert) runs both consumers on the same element, first then second.

Supplier<Employee> takes nothing and returns a fresh Employee from get(): perfect for lazy defaults.

BiFunction<Employee, Double, Employee> takes an employee plus a raise percentage and returns the raised employee.

UnaryOperator<String> is a Function<String, String>: same type in, same type out, perfect for normalising a name.

A @FunctionalInterface with exactly one abstract method can be implemented by a lambda: define your own when the built-ins do not fit.

Define TriFunction<A, B, C, R> yourself: Java caps built-ins at BiFunction to prevent interface sprawl.