Functional Programming

A lambda is a short way to write a function you can pass around like a value. It can read local variables around it, but only ones that never change after being set (effectively final). A method reference (List::size) is shorthand for a lambda that just calls that method.

A Stream lets you describe what you want done to a collection (filter, map, then collect) instead of writing loops. The middle steps don't run when you write them; nothing happens until a final step (like collect or count). Then each element is pushed through all the steps at once, not one full pass per step.

The java.util.function package has small function types (Function, Predicate, Consumer...) with helper methods that glue functions together: andThen runs another function after this one, compose runs it before, and Predicate has and/or/negate to combine yes/no tests. This lets you build a bigger operation from small reusable ones.

Mark fields final so they can't be reassigned after construction, and use unmodifiable collections (like List.of(...) or List.copyOf(...)) so nobody can add or remove elements. Immutable data can't change under you, which makes functional code and shared/parallel use safe.

A parallel stream splits the work across threads. If your lambda changes shared variables or the source collection, multiple threads collide, giving wrong or random results and crashes. So the lambdas must only depend on their input and not change shared state.

A lambda can use a local variable only if that variable's value never changes after it is set. 'Effectively final' means you could add the word final and it would still compile. Java forbids changing such captured locals to keep behavior predictable.

A lambda is params -> body. Parameters go on the left, an arrow in the middle, the body on the right. With one parameter you can drop the parentheses; a single-expression body needs no braces or return, while a block body uses { } and an explicit return.

In a lambda, this means the same thing as in the code around it — the enclosing object. In an anonymous inner class, this means the anonymous object itself, not the surrounding one.

A lambda by itself has no fixed type. The compiler looks at the surrounding context — what type is expected there — and matches the lambda to that functional interface. The same x -> x + 1 can be a Function, a UnaryOperator, or your own interface depending on where it's used.

In a lambda, this means the enclosing object (the class where the lambda is written). In an anonymous class, this means the anonymous class instance itself. The lambda does not create a new scope for this.

A method reference is shorthand for a lambda that just calls one method. The four kinds are: static (Class::staticMethod), bound instance (object::method), unbound instance (Class::instanceMethod), and constructor (Class::new).

In a bound reference (object::method) the object the method runs on is fixed when you write it. In an unbound reference (Class::method) that object is not fixed — it's passed in as the first argument each time the function is called.

ClassName::new is shorthand for a lambda that calls a constructor — which constructor is picked depends on the target interface's parameters. int[]::new is a special form that creates an array of a given length, like n -> new int[n].

The compiler looks at the functional interface the reference must satisfy, then finds a method (or constructor) whose signature is compatible — possibly treating the first parameter as the receiver. If several methods fit equally, or none do, it's a compile error.

Use a method reference when the lambda would do nothing but call one existing method with the same arguments. Use a lambda when you need extra logic, to reorder or transform arguments, or when the reference would be ambiguous or unclear.

Function<T,R> takes one value and returns another. Consumer<T> takes one value, returns nothing. Supplier<T> takes nothing, returns a value. Predicate<T> takes one value, returns a boolean.

Both glue two functions into one. f.andThen(g) runs f first, then feeds its result to g. f.compose(g) runs g first, then feeds its result to f. So andThen reads left-to-right; compose reads right-to-left.

Predicate is a function returning true/false. p.and(q) is true only if both are true; p.or(q) is true if either is true; p.negate() flips the result. Each returns a new Predicate you can keep combining.

A functional interface is an interface with exactly one abstract method (the SAM rule, Single Abstract Method). Because there is only one method to implement, you can supply it with a lambda or method reference instead of a full class.

The Bi- versions take two arguments instead of one: BiFunction<T,U,R>, BiConsumer<T,U>, BiPredicate<T,U>. UnaryOperator<T> is a Function whose input and output are the same type; BinaryOperator<T> is a BiFunction with both inputs and output the same type.

Mutable reduction combines stream elements by adding them into one mutable container (like a List or StringBuilder) instead of creating a new value each step. collect() does this: it makes a container, then drops each element into it.

groupingBy can take a second collector that runs on each group. So instead of getting lists, you can count items per group with Collectors.counting() or add them up with summingInt(). The result is a Map from key to the computed value.

groupingBy takes a function that maps each element to a key. It returns a Map where each key points to a list of all the elements that produced that key, like sorting items into labeled buckets.

Use stream.collect(Collectors.toList()) to get a List. toUnmodifiableList() gives a List you cannot change (add/remove throws). Since Java 16, stream.toList() is a shorter way to get an unmodifiable list.

toMap takes two functions: a keyMapper that turns each element into the map key, and a valueMapper that turns each element into the value. The result is a Map built from those keys and values.

Optional is a box that either holds a value or is empty. It is meant to be a method's return type when the result might be absent, so callers must handle the 'nothing' case. The most common misuse is calling get() without first checking that a value is present, which throws if it is empty.

Optional.of(x) wraps a value you know is not null; Optional.ofNullable(x) wraps a value that might be null and gives empty if it is null; Optional.empty() makes an empty Optional with no value.

get() returns the value if one is present, but throws NoSuchElementException if the Optional is empty. Calling it directly is risky because you can forget to check first, so prefer orElse, orElseThrow, or ifPresent instead.

map applies a function and wraps the result in a new Optional. flatMap is used when the function itself already returns an Optional — it flattens the result so you get Optional<T> instead of a nested Optional<Optional<T>>.

orElse takes a ready value and always evaluates it, even when the Optional has a value. orElseGet takes a function that produces the fallback only when the Optional is empty. Use orElseGet when the fallback is expensive.