Java 8 & Functional Programming

A lambda is a concise implementation of a functional interface: (params) -> body. It removes the boilerplate of anonymous inner classes and lets behaviour be passed as an argument.

• The target type is inferred from context (assignment, argument, return).
• Comparator<String> c = (a, b) -> a.length() - b.length();
• Lambdas enable the Stream API, CompletableFuture callbacks and Optional transformations.

An interface with exactly one abstract method (SAM). It may also have default, static and private methods, and may redeclare Object methods such as equals.

• @FunctionalInterface is optional; it makes the compiler reject a second abstract method.
• Comparator is functional even though it declares equals, because that is an Object method.

Four families: Function<T,R> (T to R), Predicate<T> (T to boolean), Consumer<T> (T to void), Supplier<T> (nothing to T).

• BiFunction, BiPredicate, BiConsumer take two arguments.
• UnaryOperator<T> and BinaryOperator<T> are specialisations where input and output types match.
• Primitive variants (IntFunction, ToLongFunction, IntPredicate) avoid boxing.

Function has andThen and compose; Predicate has and, or, negate and static not (Java 11).

Function<Integer, Integer> plus1 = x -> x + 1;
Function<Integer, Integer> times2 = x -> x * 2;
plus1.andThen(times2).apply(3); // (3+1)*2 = 8
plus1.compose(times2).apply(3); // (3*2)+1 = 7

• Predicate.not(String::isBlank) replaces s -> !s.isBlank().
• and/or short-circuit like &&/||.

Static (Integer::parseInt), bound instance (System.out::println), unbound instance (String::length, receiver becomes first argument) and constructor (ArrayList::new).

• A method reference is only valid if the method's signature fits the target functional interface.
• For String::compareToIgnoreCase as Comparator<String>, the first argument is the receiver.

A local variable captured by a lambda or inner class must be final or never reassigned after initialization. Captured locals are copied into the lambda, so mutation would create two diverging values.

• Instance and static fields are not subject to this rule because the lambda captures this or the class, not a copy.
• Workarounds: single-element array, AtomicInteger, or restructure with reduce/collectors.

In a lambda, this refers to the enclosing instance because a lambda introduces no new scope. In an anonymous class, this refers to the anonymous instance.

• Lambda parameters cannot shadow local variables of the enclosing method (compile error); anonymous class members can.
• A lambda has no identity of its own: toString and hashCode are not meaningful.

javac desugars the body into a private static (or instance, if it captures this) method and emits an invokedynamic instruction. On first execution the bootstrap method LambdaMetafactory.metafactory spins a hidden class implementing the interface and links the call site.

• Non-capturing lambdas are cached as a singleton; capturing ones allocate an instance per evaluation.
• Not generating classes at compile time keeps jar size small and lets the JVM change the strategy later.

A default method has a body inside an interface, letting library authors evolve interfaces without breaking implementers. It enabled Collection.stream(), List.sort and Map.getOrDefault.

• Implementers inherit the default but may override it.
• Static interface methods (Java 8) and private interface methods (Java 9) support helper logic.

Rules in order: (1) a class method (including inherited from a superclass) wins over any interface default; (2) the most specific interface wins; (3) otherwise it is a compile error and the class must override, optionally calling A.super.hello().

interface A { default String hi() { return "A"; } }
interface B { default String hi() { return "B"; } }
class C implements A, B {
    public String hi() { return A.super.hi() + B.super.hi(); }
}

A pipeline is a source, zero or more intermediate operations, and one terminal operation. Intermediate operations return a new stream lazily; nothing runs until the terminal operation is invoked.

• Sources: collections, arrays, Stream.of, Files.lines, generate, iterate.
• Elements flow one at a time through the whole chain (vertical processing), not stage by stage, except at stateful barriers like sorted.

Intermediate operations only record a stage; the terminal operation pulls elements. That allows fusion of stages and early termination.

Stream.of("a","bb","ccc")
      .filter(s -> { System.out.println("f " + s); return s.length() > 1; })
      .map(s -> { System.out.println("m " + s); return s.toUpperCase(); })
      .findFirst();
// f a, f bb, m bb  (ccc never touched)

Intermediate: limit, takeWhile (Java 9). Terminal: findFirst, findAny, anyMatch, allMatch, noneMatch. They can finish without consuming the whole source, which is what makes infinite streams usable.

• Stream.iterate(1, x -> x + 1).filter(x -> x % 7 == 0).limit(3) terminates.
• anyMatch stops on first true; allMatch on first false.

Stateless (map, filter, flatMap, peek) process each element independently. Stateful (sorted, distinct, limit, skip) need to remember earlier elements or see all of them.

• sorted is a full barrier and buffers everything.
• distinct keeps a hash set of seen elements: memory grows with cardinality.
• Stateful ops are expensive or order-sensitive in parallel pipelines.

map transforms each element one-to-one. flatMap maps each element to a stream and flattens the results into one stream.

List<List<Integer>> nested = List.of(List.of(1, 2), List.of(3));
nested.stream().flatMap(List::stream).toList(); // [1, 2, 3]

• Use it for one-to-many, for flattening Optional<Stream> style structures and for words -> chars.
• Optional.flatMap avoids Optional<Optional<T>>.

reduce(BinaryOperator) returns Optional<T>; reduce(identity, op) returns T; reduce(identity, accumulator, combiner) allows a different result type and supports parallel merging.

• The operator must be associative and the identity must be neutral, otherwise parallel results differ.
• Prefer collect for mutable results; reduce with a StringBuilder or List is a bug.

reduce is immutable reduction (each step produces a new value). collect is mutable reduction into a container via supplier, accumulator and combiner, so it avoids repeated copying.

• reduce(new ArrayList<>(), (l, e) -> { l.add(e); return l; }, ...) shares one list across threads and is incorrect in parallel.
• Collectors.toList() creates one list per thread and merges them.

Stream.toList() (Java 16) returns an unmodifiable list that permits nulls. Collectors.toList() returns a mutable list, type unspecified. Collectors.toUnmodifiableList() (Java 10) returns an unmodifiable list that rejects nulls with NPE.

• List.copyOf and List.of also reject nulls.
• Modifying the result of Stream.toList() throws UnsupportedOperationException.

It classifies elements by a key function into a Map<K, List<T>>; a downstream collector reduces each group, and a map factory chooses the map type.

Map<String, Long> countByStatus = orders.stream()
    .collect(Collectors.groupingBy(Order::status, TreeMap::new, Collectors.counting()));

• Common downstreams: counting, summingInt, mapping, averagingDouble, maxBy.
• Key function must not return null (NPE: "element cannot be mapped to a null key").
• Default map is HashMap; no ordering guarantee.

partitioningBy(predicate) always returns a Map<Boolean, List<T>> with both true and false keys present, even if one list is empty. groupingBy only creates keys that occur.

• Accepts a downstream collector, e.g. partitioningBy(p, counting()).
• Good for pass/fail splits; the map is a special compact implementation.

The two-argument toMap throws IllegalStateException: Duplicate key K (attempted merging values A and B). Supply a merge function as third argument to resolve, and a map supplier as fourth to control type.

Map<String, Integer> byEmail = users.stream().collect(
    Collectors.toMap(User::email, User::age, (a, b) -> a, LinkedHashMap::new));

• toMap also throws NPE if a value is null (it uses HashMap.merge).
• toConcurrentMap is the parallel-friendly variant.

teeing (Java 12) feeds every element into two downstream collectors and combines their results with a merger function, in a single pass.

record Stats(long count, double avg) {}
Stats s = nums.stream().collect(Collectors.teeing(
    Collectors.counting(),
    Collectors.averagingInt(i -> i),
    Stats::new));

• Removes the need to traverse a source twice or to hold intermediate maps.

They adapt downstream collectors. mapping transforms before collecting; filtering and flatMapping (Java 9) do the same for filter/flatMap inside each group.

• groupingBy(k, filtering(p, toList())) keeps empty groups; pre-filtering with .filter(p) drops the group key entirely.
• summarizingInt/Long/Double returns count, sum, min, max, average at once.

joining(delim, prefix, suffix) concatenates CharSequence elements using a StringBuilder. Sorting uses Comparator.comparing(...).thenComparing(...) and reversed().

people.stream()
      .sorted(Comparator.comparing(Person::city).thenComparing(Person::age, Comparator.reverseOrder()))
      .map(Person::name).collect(Collectors.joining(", ", "[", "]"));

• Comparator.nullsFirst/nullsLast wrap comparators for null-safe sorting.

sorted() on an ordered stream is stable; it uses the same TimSort as List.sort. It buffers all elements, so it is a barrier and costs O(n log n).

• Elements must be Comparable or a comparator must be supplied, otherwise ClassCastException at runtime.
• On unordered streams stability is not promised.

Optional<T> is a container for a value that may be absent, designed as a return type to make "no result" explicit and to prevent NPE through composable operations.

• Create with of (non-null), ofNullable, empty.
• Query with map, flatMap, filter, orElse, orElseGet, orElseThrow, ifPresent, ifPresentOrElse (9), or (9), stream (9), isEmpty (11).

orElse(value) evaluates its argument eagerly, always. orElseGet(supplier) only invokes the supplier when the Optional is empty.

repo.findCached(id).orElse(repo.loadFromDb(id));     // DB hit every time
repo.findCached(id).orElseGet(() -> repo.loadFromDb(id)); // only on miss

• orElseThrow(Supplier) is similar: lazy exception creation.

Misuse includes: Optional as a field, method parameter or collection element; isPresent() followed by get(); returning null from a method that returns Optional; Optional.get() without a check; wrapping in Optional only to unwrap immediately.

• Use Optional<T> as a return type only.
• Return empty collections, not Optional<List<T>>.
• Do not use Optional in JPA entities or DTOs for JSON; serialization and frameworks handle it poorly.
• Optional<Integer> is boxed; prefer OptionalInt in hot code.

map applies a function and wraps the result with ofNullable, so a null result becomes empty. flatMap takes a function that already returns an Optional and avoids nesting.

Optional<String> city = user.flatMap(User::address).map(Address::city);
// User::address returns Optional<Address>

java.time (JSR-310) provides immutable, thread-safe types: LocalDate, LocalTime, LocalDateTime, Instant, ZonedDateTime, OffsetDateTime, Duration, Period. It replaces Date (mutable, misnamed, 1900-based years) and Calendar (0-based months, not thread-safe).

• DateTimeFormatter is thread-safe; SimpleDateFormat is not.
• Arithmetic returns new instances: date.plusDays(1).

Instant is a point on the UTC timeline (nanoseconds since epoch). LocalDateTime is a date and time without zone. OffsetDateTime adds a fixed UTC offset. ZonedDateTime adds a region rule (Europe/Paris) so daylight saving is handled.

• Store/exchange timestamps as Instant or UTC OffsetDateTime; convert to zoned time for display.
• For DB columns of type timestamp with time zone, Hibernate 6 and JDBC 4.2 support OffsetDateTime/Instant.

Duration is time-based (seconds and nanos), used with Instant/LocalTime. Period is date-based (years, months, days), used with LocalDate.

• ChronoUnit.DAYS.between(a, b) gives total units.
• Adding Period.ofDays(1) to a ZonedDateTime keeps local time across DST; Duration.ofHours(24) adds exactly 24h.

Use DateTimeFormatter constants; they are immutable and thread-safe. Parsing is strict about the target type: a pattern without a time part cannot parse into LocalDateTime.

DateTimeFormatter f = DateTimeFormatter.ofPattern("dd-MM-uuuu");
LocalDate d = LocalDate.parse("15-08-2024", f);

• Prefer uuuu over yyyy (year-of-era) when using ResolverStyle.STRICT.
• ISO formats have built-ins: DateTimeFormatter.ISO_LOCAL_DATE.

Future only supports blocking get(). CompletableFuture is a composable promise: chain stages with thenApply, thenCompose, thenCombine, handle errors with exceptionally/handle, and complete manually with complete.

• supplyAsync/runAsync run on ForkJoinPool.commonPool() by default; pass an Executor for IO-bound work.
• allOf/anyOf coordinate several futures.

An exception completes the stage exceptionally and skips downstream thenApply stages. exceptionally(fn) recovers; handle((v, ex) -> ...) sees both; whenComplete observes without changing the result.

• join() throws CompletionException wrapping the cause; get() throws ExecutionException.
• Inside exceptionally the throwable of dependent stages is often wrapped in CompletionException; unwrap with getCause().
• orTimeout and completeOnTimeout (Java 9) add timeouts.

thenApply maps the value (like map). thenCompose flattens a function returning another future (like flatMap). thenCombine joins two independent futures with a bi-function once both finish.

• thenApplyAsync variants run the stage on another executor thread rather than the completing thread.
• Non-async callbacks may run on the thread that completes the future, or the caller if already complete.

A closure is a function bundled with the variables it captured from its enclosing scope. In Java, captured locals are copied as values into the lambda instance, which is why they must be effectively final.

Function<Integer, Integer> adder(int n) { return x -> x + n; }
adder(5).apply(3); // 8

• Captured this makes a lambda hold the enclosing object, which can leak memory if the lambda is stored long-term.

A record (final in Java 16) is a transparent immutable data carrier: record Point(int x, int y) {} generates private final fields, canonical constructor, accessors x(), y(), equals, hashCode and toString.

• Compact constructor validates or normalizes: record Range(int lo, int hi) { Range { if (lo > hi) throw new IllegalArgumentException(); } }.
• Records cannot extend classes, cannot declare instance fields beyond components, but can implement interfaces and have static members.

instanceof patterns (Java 16) bind a typed variable: if (o instanceof String s && s.length() > 3). Switch patterns (Java 21) match on type and guard with when, and the switch is an expression that must be exhaustive.

String describe(Object o) {
    return switch (o) {
        case null -> "null";
        case Integer i when i > 10 -> "big " + i;
        case Integer i -> "int " + i;
        case String s -> "str " + s;
        default -> "other";
    };
}

• Case order matters; a dominated pattern is a compile error.

Record patterns (final in Java 21) deconstruct a record in a pattern, optionally nested.

sealed interface Shape permits Circle, Rect {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}

double area(Shape s) {
    return switch (s) {
        case Circle(double r) -> Math.PI * r * r;
        case Rect(double w, double h) -> w * h;
    };
}

sealed (final in Java 17) restricts which classes can extend or implement a type via permits. Each permitted subtype must be final, sealed or non-sealed.

• Permitted subtypes must be in the same module (or same package in the unnamed module); permits can be omitted when all are in the same file.
• They give a closed set of subtypes, enabling exhaustive switches without default.

Key additions: var (10), List.of/Map.of (9), switch expressions (14), text blocks (15), records (16), sealed classes (17), pattern switch and record patterns (21), Stream.toList (16), virtual threads (21), sequenced collections (21).

• var is local-only type inference, still statically typed.
• Text blocks use """ and strip incidental indentation.

A switch expression yields a value, uses arrow cases with no fall-through, and must be exhaustive. Use yield inside a block.

int days = switch (month) {
    case FEB -> 28;
    case APR, JUN, SEP, NOV -> 30;
    default -> { log(month); yield 31; }
};

parallelStream() splits the source with a Spliterator and runs stages on ForkJoinPool.commonPool() using fork/join, then combines results. It helps for CPU-bound, stateless, associative work on large, cheaply splittable sources.

• Good: ArrayList, arrays, IntStream.range. Poor: LinkedList, Stream.iterate, BufferedReader.lines.
• Rule of thumb: N x Q > 10,000 (elements times per-element cost).

Shared common pool contention, non-thread-safe accumulation, order-dependent logic, blocking I/O inside tasks and unpredictable ordering.

• Blocking calls in a parallel stream starve the shared pool used by every other parallel stream and CompletableFuture default.
• Mutating shared state (forEach(list::add)) causes lost updates; use collect.
• forEach is unordered; forEachOrdered preserves order but loses parallel benefit.
• Isolation trick: submit the terminal operation to a custom ForkJoinPool; it relies on implementation behaviour.

A Spliterator traverses (tryAdvance, forEachRemaining) and splits (trySplit) a source. Its characteristics (ORDERED, SIZED, SORTED, DISTINCT, IMMUTABLE, CONCURRENT, SUBSIZED, NONNULL) let the framework skip work.

• ArrayList is SIZED | SUBSIZED | ORDERED, so splitting is balanced and count() can be O(1).
• HashSet is not ordered; sorted() on a TreeSet source can skip sorting (SORTED).
• Stream.count() may skip the pipeline entirely if size is known and no filtering stage exists (Java 9+), which means peek may not run.

Specialised streams avoid boxing and offer numeric terminals: sum, average, min, max, summaryStatistics. Convert with mapToInt, mapToObj, boxed.

int total = orders.stream().mapToInt(Order::qty).sum();
IntStream.rangeClosed(1, 5).sum(); // 15

• average() returns OptionalDouble; sum() of an empty stream is 0.
• IntStream.sum() overflows silently; use LongStream or mapToLong for large totals.

Stream.iterate(seed, f) and Stream.generate(supplier) produce infinite streams; iterate(seed, hasNext, next) (Java 9) is bounded like a for loop. takeWhile/dropWhile slice by predicate on ordered streams.

Stream.iterate(1, i -> i < 100, i -> i * 2).toList(); // [1,2,4,...,64]
Stream.of(1, 2, 5, 1).takeWhile(i -> i < 3).toList();  // [1, 2]

peek(Consumer) is an intermediate operation intended for debugging: it observes elements as they flow. It must not be relied on for side effects in production because it may be skipped (e.g. count() optimisation) or run out of order in parallel.

Behavioural parameters must be non-interfering (do not modify the source during the pipeline) and, for most operations, stateless. Modifying an ArrayList source during traversal throws ConcurrentModificationException, usually at the terminal operation.

• Late-binding: a stream sourced from a collection reads the collection at terminal-op time, so modifications before the terminal op are visible.
• Side effects in map/filter hurt parallel correctness and readability.

Streams from ordered sources (List, arrays) have an encounter order. findFirst returns the first in that order. findAny may return any element, which is cheaper in parallel.

• unordered() removes the constraint and can speed up distinct, limit and collect in parallel.
• HashSet streams have no meaningful encounter order.

Prefer pure functions and immutable data, push side effects to the edges, keep lambdas short (extract a named method or method reference), and avoid streams where a plain loop is clearer.

• Use Function/Supplier for strategy-like variation instead of class hierarchies.
• Name complex predicates (Predicate<Order> isOverdue = ...).
• Avoid checked exceptions in lambdas by wrapping in a small adapter, not by sneaky throws.

Standard functional interfaces declare no checked exceptions. Options: wrap in a try/catch in the lambda and rethrow as unchecked, define a custom functional interface that throws, or use a wrapper helper.

@FunctionalInterface interface ThrowingFn<T, R> { R apply(T t) throws Exception; }

static <T, R> Function<T, R> unchecked(ThrowingFn<T, R> f) {
    return t -> { try { return f.apply(t); } catch (Exception e) { throw new RuntimeException(e); } };
}

The second terminal call throws IllegalStateException: stream has already been operated upon or closed.

Stream<String> s = Stream.of("a", "b");
s.count();
s.count(); // IllegalStateException

• Fix: create a new stream from the source, or use a Supplier<Stream<T>>.

Nothing, because there is no terminal operation.

Stream.of(1, 2, 3).peek(System.out::println).map(i -> i * 2);

Adding .toList() prints 1 2 3, one per line, in order.

Elements flow one at a time through the whole chain.

Stream.of("x", "yy", "zzz")
    .filter(s -> { System.out.print("F" + s + " "); return s.length() > 1; })
    .map(s -> { System.out.print("M" + s + " "); return s; })
    .collect(Collectors.toList());
// Fx Fyy Myy Fzzz Mzzz

Two users share an email, so toMap(User::email, Function.identity()) throws IllegalStateException. Decide the policy and encode it in the merge function.

Map<String, User> latest = users.stream().collect(Collectors.toMap(
    User::email, u -> u,
    BinaryOperator.maxBy(Comparator.comparing(User::updatedAt))));

• Or group into Map<String, List<User>> if duplicates are legitimate.
• Silently keeping (a, b) -> a hides data problems; log or reject if duplicates are unexpected.

Use groupingBy with summingDouble, or with BigDecimal use reducing.

Map<Long, BigDecimal> totals = orders.stream().collect(
    Collectors.groupingBy(Order::customerId,
        Collectors.reducing(BigDecimal.ZERO, Order::amount, BigDecimal::add)));

• Never use double for money; summingDouble rounds incorrectly.
• Empty input yields an empty map, not zero rows.

Group and sum, then sort entries descending and limit.

List<Long> top3 = totals.entrySet().stream()
    .sorted(Map.Entry.<Long, BigDecimal>comparingByValue().reversed())
    .limit(3)
    .map(Map.Entry::getKey)
    .toList();

• For very large maps use a bounded PriorityQueue of size 3, which is O(n log 3).
• Ties are resolved by encounter order since sorted is stable.

distinct() uses equals. For a field-based dedupe, key by the field and keep the first.

List<User> unique = new ArrayList<>(users.stream().collect(Collectors.toMap(
    User::email, u -> u, (a, b) -> a, LinkedHashMap::new)).values());

• Alternative: stateful filter with a Set<String> seen and seen.add(u.email()), valid only for sequential streams.
• Record types get field-based equals, so distinct() works directly.

skip((page - 1) * size).limit(size); sort first to give a stable order.

List<Item> pageOf(List<Item> all, int page, int size) {
    return all.stream()
        .sorted(Comparator.comparing(Item::id))
        .skip((long) (page - 1) * size)
        .limit(size)
        .toList();
}

• Cast to long to avoid int overflow on large pages.
• Paginating the full list in memory is only acceptable for small data; for large data push LIMIT/OFFSET or keyset pagination to the database.

Map<Boolean, List<Order>> parts = orders.stream()
    .collect(Collectors.partitioningBy(o -> o.amount().signum() > 0));
List<Order> valid = parts.get(true);
List<Order> rejected = parts.get(false);

• Both keys exist even when the list is empty, so get never returns null.
• Use partitioningBy(p, counting()) for counts only.

Use teeing or summarizingDouble.

var r = prices.stream().collect(Collectors.teeing(
    Collectors.summingDouble(Double::doubleValue),
    Collectors.counting(),
    (sum, n) -> n == 0 ? 0.0 : sum / n));

• DoubleSummaryStatistics gives min, max, sum, count and average without teeing.
• Guard against divide-by-zero on an empty stream.

Behaviour is undefined: lost elements, ArrayIndexOutOfBoundsException, or null slots.

List<Integer> out = new ArrayList<>();
IntStream.range(0, 100_000).parallel().forEach(out::add); // unsafe

• Fix: .boxed().collect(Collectors.toList()), which uses per-thread containers.
• Collections.synchronizedList would be correct but contended.

Blocking threads of the shared ForkJoinPool.commonPool() (cores - 1 threads) starve every other parallel stream and default CompletableFuture task in the JVM.

• Use a dedicated executor with CompletableFuture.supplyAsync(task, ioExecutor), or virtual threads (Java 21) for blocking I/O.
• Bound concurrency, apply timeouts and rate-limit downstream.
• Streams are for CPU-bound data processing, not I/O fan-out.

IntStream.rangeClosed(1, 4).parallel().reduce(0, (a, b) -> a - b);

Sequentially this is ((((0-1)-2)-3)-4) = -10. In parallel the pipeline splits and the combiner subtracts partial results, so the answer can differ (for example -2 or others) from run to run.

• Operators must be associative; identity must satisfy op(identity, x) == x.
• reduce(1, (a, b) -> a + b) has a non-neutral identity and returns different results when split.

Optional<String> o = Optional.of("a");
String r = o.orElse(compute());

compute() is executed even though o is present, so any side effect or cost happens. With orElseGet(this::compute) it is skipped.

// before
if (order != null && order.customer() != null && order.customer().address() != null)
    return order.customer().address().city();
return "UNKNOWN";

// after
return Optional.ofNullable(order)
    .map(Order::customer)
    .map(Customer::address)
    .map(Address::city)
    .orElse("UNKNOWN");

• Better still: design domain types to avoid null in the first place.
• Allocation of Optional objects is negligible outside hot loops.

Collections already express "none" with an empty collection, so double wrapping forces callers to handle two empty states. Return List<Order> and never return null.

• Spring Data findAll... returns empty collections, not null.
• Reserve Optional for single-value lookups like findById.

get() on empty throws NoSuchElementException. Prefer orElseThrow() (no-arg, Java 10) which signals intent, or a domain exception.

User u = repo.findById(id)
    .orElseThrow(() -> new UserNotFoundException(id));

• Use ifPresentOrElse when both branches have side effects.
• Do not guard get with isPresent as a habit; map/orElse are clearer.

JPA/Hibernate does not map Optional<T> fields: you get a mapping error or the field is treated as a basic type with no converter. The usual practice is a nullable field with an Optional getter.

private String nickname; // nullable column
public Optional<String> getNickname() { return Optional.ofNullable(nickname); }

• Optional is also not Serializable, which breaks Java serialization and some caches.
• Jackson needs jackson-datatype-jdk8 to serialise Optional sensibly, and still renders absent values awkwardly.

Set<String> tags = orders.stream()
    .flatMap(o -> o.tags().stream())
    .collect(Collectors.toCollection(TreeSet::new));

Result: sorted set of all distinct tags. A null tags() list would throw NPE, so return an empty list or wrap with Optional.ofNullable(...).stream().flatMap(List::stream).

Map<String, Long> freq = Arrays.stream(text.toLowerCase().split("\\W+"))
    .filter(w -> !w.isEmpty())
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

• Values are Long, not Integer; use summingInt(w -> 1) for Integer.
• For "a b a" the result is {a=2, b=1} (map order unspecified).

Map<YearMonth, BigDecimal> byMonth = orders.stream().collect(
    Collectors.groupingBy(o -> YearMonth.from(o.createdAt().atZone(ZoneOffset.UTC)),
        TreeMap::new,
        Collectors.reducing(BigDecimal.ZERO, Order::amount, BigDecimal::add)));

• Decide the business timezone for the month boundary; UTC vs customer zone gives different groups.
• TreeMap gives chronological iteration.

NullPointerException: element cannot be mapped to a null key. Map nulls to a sentinel.

Collectors.groupingBy(u -> Optional.ofNullable(u.country()).orElse("UNKNOWN"))

• HashMap itself allows null keys, but groupingBy rejects them explicitly.
• partitioningBy has no such issue because keys are booleans.

int total = 0;
list.forEach(x -> total += x); // error: local variables referenced from a lambda must be final or effectively final

Fix with a terminal operation: int total = list.stream().mapToInt(Integer::intValue).sum();. Using AtomicInteger compiles but is an anti-pattern for what is a reduction.

List<Runnable> rs = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    int copy = i;
    rs.add(() -> System.out.print(copy + " "));
}
rs.forEach(Runnable::run); // 0 1 2

Using i directly does not compile because i is mutated. With an enhanced for (int v : arr), each iteration has a fresh variable so capture works.

class C implements A, B where both have default hi() fails with "types A and B are incompatible; class C inherits unrelated defaults for hi()". Override in C and delegate with A.super.hi().

• If B extends A and overrides hi(), B wins; no error.
• If C extends a class that defines hi(), the class method wins.

Source and binary compatibility is mostly kept, but conflicts arise if an implementer's superclass or another interface already declares a same-signature method with a different return type, or incompatible final/visibility semantics (default methods are public).

• Class methods that are not public cannot implement an interface method (compile error).
• Libraries such as Collection.removeIf (Java 8) clashed with some custom collections that already had removeIf.

Split the pipeline into named intermediate variables or use peek temporarily to see element flow. Remember laziness: a debugger breakpoint in a lambda is hit per element, interleaved.

list.stream()
    .peek(x -> log.debug("in {}", x))
    .filter(Item::active)
    .peek(x -> log.debug("active {}", x))
    .map(Item::price)
    .toList();

• IntelliJ's "Trace Current Stream Chain" visualises each stage.
• Extract complex lambdas into named methods so stack traces are readable.
• Remove peek before shipping.

list.stream().forEach(x -> { if (x < 0) list.remove(x); });

Throws ConcurrentModificationException (for ArrayList) because the source is structurally modified during traversal, violating non-interference. Use list.removeIf(x -> x < 0) or collect into a new list.

Because the list is SIZED and map preserves size, count() returns the size directly (Java 9+) and expensive is never called. In Java 8 it was always executed.

• Do not rely on side effects inside map/peek to be executed.
• Adding a filter or flatMap removes the size info and the pipeline runs.

For tight loops over small data a plain loop is usually faster: no lambda allocation, no pipeline objects, better JIT inlining. For moderate data the difference is negligible and clarity matters more.

• Boxed streams (Stream<Integer>) are much slower than IntStream or arrays.
• Streams add ~tens of nanoseconds of setup; irrelevant outside very hot paths.
• Measure with JMH, not System.nanoTime in main; JIT warm-up skews results.
• Parallel only after measuring.

Stream<Integer> stores Integer objects; sum via reduce(0, Integer::sum) unboxes and reboxes. Use mapToInt(...).sum() to stay primitive.

• Integer cache covers only -128..127; others allocate.
• Collectors.summingInt and averagingInt avoid reboxing of the accumulator via arrays internally.

list.stream().filter(p).count() > 0 scans the whole list. anyMatch(p) stops at the first hit.

• For membership use Set.contains (O(1)) instead of a stream over a list.
• noneMatch(p) is the negative form.

Map<Long, Order> byId = orders.stream().collect(Collectors.toMap(
    Order::id, Function.identity(),
    (a, b) -> { throw new IllegalStateException("dup id " + a.id()); },
    LinkedHashMap::new));

A custom merge function that throws gives a clearer message and preserves order via the map supplier. The default toMap would yield a HashMap.

AtomicInteger seq = new AtomicInteger();
list.parallelStream().map(x -> x + "-" + seq.incrementAndGet()).toList();

Counter values are assigned in execution order, not encounter order, so the output list order is preserved but the numbers are scrambled. The result changes run to run.

• Use IntStream.range with indices, or assign ids after collecting.
• Stream.toList() keeps encounter order for ordered sources even in parallel.

Files.lines(path) is lazy and constant-memory, but it holds an open file handle; close it with try-with-resources.

try (Stream<String> lines = Files.lines(path)) {
    long errors = lines.filter(l -> l.contains("ERROR")).count();
}

• Throws UncheckedIOException on read errors mid-stream.
• Parallel splitting is poor for Files.lines on small files; it works better on large files via a special spliterator, but measure.

CompletableFuture<BigDecimal> total =
    CompletableFuture.supplyAsync(() -> userClient.get(id), io)
        .thenCompose(u -> CompletableFuture.supplyAsync(() -> orderClient.byUser(u.id()), io))
        .thenApply(os -> os.stream().map(Order::amount).reduce(BigDecimal.ZERO, BigDecimal::add));

Using thenApply for the second call would give a nested future. Always pass an executor for blocking clients.

var a = CompletableFuture.supplyAsync(this::loadProfile, io);
var b = CompletableFuture.supplyAsync(this::loadOrders, io);
var c = CompletableFuture.supplyAsync(this::loadPrefs, io);
CompletableFuture.allOf(a, b, c).join();
Page page = new Page(a.join(), b.join(), c.join());

allOf returns CompletableFuture<Void>; read results from each future afterwards. If any fails, join() on allOf throws CompletionException, but the other tasks keep running (no cancellation propagation).

supplyAsync(...) returns a future; if nobody calls join/get or attaches exceptionally/handle, the failure is captured silently inside the future. With runAsync fire-and-forget this goes unnoticed.

CompletableFuture.runAsync(this::risky, io)
    .exceptionally(ex -> { log.error("failed", ex); return null; });

• Always terminate chains with error handling.
• get() wraps in ExecutionException, join() in CompletionException.

LocalDateTime has no zone, so the stored value is interpreted in whatever zone the server, driver or reader uses. Services in different zones disagree on the instant.

• Store Instant (UTC) and convert to a ZoneId only at presentation.
• Use ZonedDateTime when the local wall clock and rule matter (e.g. a recurring 09:00 meeting in Europe/Berlin).
• Set hibernate.jdbc.time_zone=UTC for consistent behaviour.

ZonedDateTime t = ZonedDateTime.of(2024, 3, 9, 12, 0, 0, 0, ZoneId.of("America/New_York"));
t.plusDays(1);              // 2024-03-10T12:00-04:00 (local time kept)
t.plus(Duration.ofHours(24)); // 2024-03-10T13:00-04:00

plusDays works on the local timeline; Duration works on the instant timeline. The DST gap on 10 March skips one hour, so 24 elapsed hours land at 13:00.

long days = ChronoUnit.DAYS.between(LocalDate.of(2024, 1, 1), LocalDate.of(2024, 3, 1)); // 60
int age = Period.between(birthDate, LocalDate.now(clock)).getYears();

2024 is a leap year, hence 31 + 29 = 60 days. Period.getDays() returns only the day component, not the total.

SimpleDateFormat keeps an internal Calendar, so concurrent parse/format calls corrupt each other and give wrong dates or NumberFormatException. Replace with the immutable DateTimeFormatter, which is safe to share as a constant.

findFirst on an ordered parallel stream must return the first element in encounter order, so later splits may be discarded after the first split finishes; it is deterministic but slower. findAny may return any matching element, differing between runs.

• For search-where-any-is-fine (e.g. any matching record), use findAny.
• Calling .unordered() lets other ops be cheaper too.

public record CreateOrder(String sku, int qty, List<String> tags) {
    public CreateOrder {
        Objects.requireNonNull(sku);
        if (qty <= 0) throw new IllegalArgumentException("qty must be > 0");
        tags = List.copyOf(tags);
    }
}

• The compact constructor assigns fields at the end; reassigning the parameter tags is how you normalise.
• Jackson 2.12+ and Spring Boot 3 deserialize records natively.
• List.copyOf makes a defensive immutable copy and rejects null elements.

record P(int x, List<String> l) {}
new P(1, List.of("a")).equals(new P(1, List.of("a"))); // true

Generated equals compares components with equals (primitives by value). Arrays as components would compare by reference, so record R(int[] a) gives false for equal contents.

sealed interface Event permits Created, Cancelled, Shipped {}
record Created(String id) implements Event {}
record Cancelled(String id, String reason) implements Event {}
record Shipped(String id, String carrier) implements Event {}

String log(Event e) {
    return switch (e) {
        case Created c -> "created " + c.id();
        case Cancelled(var id, var why) -> "cancelled " + id + ": " + why;
        case Shipped s -> "shipped via " + s.carrier();
    };
}

No default, so adding a new permitted subtype causes a compile error at every switch, which is the intent of sealed hierarchies.

switch (o) {
    case Number n -> ...;
    case Integer i -> ...; // error: this case label is dominated by a preceding case label
    default -> ...;
}

A more general pattern before a specific one makes the specific one unreachable. Order specific first, general last; guarded patterns (when) go before their unguarded counterparts.

sealed interface Result<T> permits Ok, Err {}
record Ok<T>(T value) implements Result<T> {}
record Err<T>(String message) implements Result<T> {}

String render(Result<Order> r) {
    return switch (r) {
        case Ok<Order>(var o) -> "order " + o.id();
        case Err<Order>(var m) -> "failed: " + m;
    };
}

Callers cannot forget the failure branch. Use for expected business outcomes (validation, not found); keep exceptions for unexpected faults.

sorted().limit(k) buffers all n elements and sorts them in O(n log n), although the JDK has a top-k optimisation in some paths. For top-k over huge data, keep a bounded PriorityQueue of size k or push ORDER BY ... LIMIT into SQL.

PriorityQueue<Order> heap = new PriorityQueue<>(Comparator.comparing(Order::amount));
for (Order o : orders) { heap.add(o); if (heap.size() > 3) heap.poll(); }

The returned list type is unspecified; today it is ArrayList, so mutation works, but this is not guaranteed. If your API promises immutability, return Stream.toList() or List.copyOf, and document it.

• Returning internal mutable lists leaks internal state; return unmodifiable views or copies.
• Collectors.toUnmodifiableList() rejects null elements.

Spring Data JPA can return Stream<T> from query methods, but the stream keeps a cursor open and must be consumed inside a transaction and closed. Using it after the transaction ends gives errors, and forgetting to close leaks connections.

@Transactional(readOnly = true)
public long countActive() {
    try (Stream<User> s = repo.streamAllActive()) {
        return s.filter(User::verified).count();
    }
}

Stream.of(1, 2, 3, 1, 2).takeWhile(i -> i < 3).toList(); // [1, 2]
Stream.of(1, 2, 3, 1, 2).filter(i -> i < 3).toList();    // [1, 2, 1, 2]
Stream.of(1, 2, 3, 1, 2).dropWhile(i -> i < 3).toList(); // [3, 1, 2]

Optional.stream() (Java 9) turns an Optional into a 0-or-1 stream, handy for dropping empties after a lookup.

List<User> users = ids.stream()
    .map(repo::findById)          // Stream<Optional<User>>
    .flatMap(Optional::stream)    // drops empties
    .toList();

This issues one query per id (N+1); prefer findAllById(ids).

Comparator<User> c = Comparator
    .comparing(User::lastName, Comparator.nullsLast(String.CASE_INSENSITIVE_ORDER))
    .thenComparing(User::age, Comparator.reverseOrder());

Without nullsLast, a null lastName raises NPE inside the comparator. Prefer comparingInt/comparingLong to avoid boxing for primitive keys.

When each strategy is one method, map names to lambdas.

Map<String, BinaryOperator<BigDecimal>> rules = Map.of(
    "SUM", BigDecimal::add,
    "MAX", BigDecimal::max);
BigDecimal r = rules.get(op).apply(a, b);

Fewer classes, easy testing. For strategies with state, configuration or several methods, keep a proper interface and class.