Predicate, Function, Consumer, Supplier — Java's Core Functional Interfaces

These four interfaces capture the four basic shapes of computation:

`Function` — transformation

• Signature: R apply(T t) — takes T, returns R
• Used in map
• Example: String::length, User::getName
• Combinators: andThen (this then next), compose (next then this), Function.identity()
• Variants: BiFunction, UnaryOperator (T to T), BinaryOperator (used in reduce)

`Predicate` — test

• Signature: boolean test(T t) — takes T, returns boolean
• Used in filter, anyMatch, allMatch, noneMatch
• Example: String::isEmpty, User::isActive
• Combinators: and, or, negate
• Java 11+: Predicate.not(String::isBlank) reads better than s -> !s.isBlank()

`Consumer` — side effect

• Signature: void accept(T t) — takes T, returns nothing
• Used in forEach, peek
• Example: System.out::println, repo::save
• Combinator: andThen (run this then the next)
• Don't abuse — if you find yourself reaching for forEach to mutate state, the imperative loop or a proper collector is usually clearer

`Supplier` — lazy production

• Signature: T get() — takes nothing, returns T
• Used in Optional.orElseGet, Map.computeIfAbsent, Stream.generate, lazy defaults
• Example: ArrayList::new, UUID::randomUUID
• Critical distinction: Optional.orElse(expensiveDefault()) calls the default eagerly; orElseGet(() -> expensiveDefault()) is lazy

Two-argument variants

• BiFunction, BiPredicate, BiConsumer
• For three or more inputs, define a custom functional interface or use a record/tuple
• Map.forEach takes a BiConsumer

Primitive specializations — avoid boxing

• IntFunction, ToIntFunction, IntUnaryOperator, IntPredicate, IntConsumer, IntSupplier
• Same family for Long and Double
• Use them in hot paths and when the API takes primitives
• Stream pipelines: .mapToInt(...).sum() is faster than .map(...).reduce(0, Integer::sum) — zero boxing

How they map to stream operations

• map(Function) — transform
• filter(Predicate) — select
• forEach(Consumer) — side effect
• peek(Consumer) — debugging
• Stream.generate(Supplier) — infinite stream
• reduce(identity, BinaryOperator) — fold

Composition examples

• Function: String::trim andThen String::toUpperCase → trim then uppercase
• Predicate: isActive.and(isAdmin), isAdmin.negate(), Predicate.not(String::isBlank)
• Consumer: log.andThen(save) — log first, then save
• Supplier: no built-in combinators — chain manually if needed

Common pitfalls

• Confusing Function and BiFunction — watch the parameter count
• Consumer returns void — use Function if you need a value back
• orElse vs orElseGet — eager vs lazy; use orElseGet for expensive defaults
• Boxing in hot paths — use primitive specializations
• Checked exceptions — standard interfaces don't declare them; wrap in RuntimeException or define a custom interface

Recommendation: Memorize these four signatures — they're the foundational vocabulary of modern Java. When designing an API or writing a stream, ask "which shape is this?" — transformation (Function), test (Predicate), side-effect (Consumer), or lazy producer (Supplier) — and pick the matching interface. Use combinators (andThen, and, or, negate, Predicate.not) instead of long lambda bodies; they read better and stay testable. Reach for primitive specializations (IntPredicate, ToIntFunction) in hot paths to avoid GC pressure from boxing. Always prefer `orElseGet` over `orElse` when the default is expensive to compute. And remember: if your lambda is more than a few lines, extract it to a named method — the symbol gives you a stack trace, a test target, and a place to document intent.