Java 8+

// Fast for CPU-bound computations:
long count = largeNumberList.parallelStream()
    .filter(PrimeChecker::isPrime)
    .count();

List<Integer> list = List.of(2, 4, 6, 7, 8, 10);
// Stops as soon as odd number 7 is encountered:
List<Integer> evens = list.stream()
    .takeWhile(n -> n % 2 == 0)
    .collect(Collectors.toList()); // [2, 4, 6]

// IntStream eliminates wrapper objects and provides range + sum:
int total = IntStream.rangeClosed(1, 100).sum(); // 5050

IntSummaryStatistics stats = IntStream.of(10, 20, 30).summaryStatistics();
System.out.println("Avg: " + stats.getAverage() + ", Max: " + stats.getMax());

Optional<String> opt = Optional.of("Real Value");
// orElse runs computeDefault() even though value is present!
String v1 = opt.orElse(computeDefault());
// orElseGet avoids running lambda because value is present:
String v2 = opt.orElseGet(() -> computeDefault());

public Optional<User> findUserById(int id) {
    User user = database.find(id);
    return Optional.ofNullable(user);
}
// Safe usage:
String name = findUserById(10)
    .map(User::getName)
    .orElse("Default User");

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
// Partitions into true (even) and false (odd) keys:
Map<Boolean, List<Integer>> evenOddMap = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

record Employee(String dept, String name, int salary) {}
List<Employee> list = getEmployees();
// Group by dept and calculate average salary per department:
Map<String, Double> avgSalaryByDept = list.stream()
    .collect(Collectors.groupingBy(
        Employee::dept,
        Collectors.averagingInt(Employee::salary)
    ));

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
// 2-argument reduce: identity + accumulator
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
// Equivalent method reference:
int sumRef = numbers.stream().reduce(0, Integer::sum);

List<Integer> list = List.of(1, 2, 3, 4, 5);
// In parallel stream, findAny is faster and non-deterministic:
Optional<Integer> any = list.parallelStream().filter(n -> n > 2).findAny();
// findFirst strictly preserves encounter order:
Optional<Integer> first = list.parallelStream().filter(n -> n > 2).findFirst();

List<String> list = List.of("Apple", "Banana", "Avocado");
String first = list.stream()
    .filter(s -> s.startsWith("A")) // Evaluated only until first match found
    .findFirst() // Short-circuiting terminal operation
    .orElse("None");

List<List<String>> nested = List.of(
    List.of("A", "B"),
    List.of("C", "D")
);
// flatMap flattens Stream<List<String>> into Stream<String>:
List<String> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList()); // ["A", "B", "C", "D"]

List<String> names = List.of("Anna", "Bob", "Alex");
// filter and map are lazy intermediate operations;
// collect is the terminal operation that triggers processing:
List<String> result = names.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// 1. Static: Math::max
// 2. Instance on specific object: System.out::println
// 3. Instance on arbitrary type: String::toUpperCase
// 4. Constructor: ArrayList::new
Function<String, String> upper = String::toUpperCase;
Supplier<List<String>> listSupplier = ArrayList::new;

Predicate<String> isLong = s -> s.length() > 5;
Function<String, Integer> getLength = String::length;
Consumer<String> printer = System.out::println;
Supplier<Double> randomSupplier = Math::random;

@FunctionalInterface
interface Transformer<T, R> {
    R transform(T input); // Single abstract method
    default void log(T input) { System.out.println("Transforming: " + input); }
}