Functional Programming in Java

@FunctionalInterface
public interface Transformer<T> {
    T transform(T input);
    // Default and static methods are allowed
    default Transformer<T> andThen(Transformer<T> after) {
        return input -> after.transform(this.transform(input));
    }
}

Function<String, Integer> strLength = String::length;
Predicate<Integer> isEven = n -> n % 2 == 0;
Consumer<String> printer = System.out::println;
Supplier<List<String>> listFactory = ArrayList::new;
UnaryOperator<String> toUpper = String::toUpperCase;
BinaryOperator<Integer> sum = Integer::sum;

// Full form
(int a, int b) -> { return a + b; }

// Type inference
(a, b) -> a + b

// Single parameter (no parentheses)
x -> x * 2

// No parameters
() -> System.out.println("Hello")

// Multi-line body
(a, b) -> {
    int result = a + b;
    log.info("Sum: {}", result);
    return result;
}

String prefix = "Hello"; // effectively final
Function<String, String> greeter = name -> prefix + " " + name; // OK

String greeting = "Hi";
greeting = "Hello"; // re-assignment breaks effectively final
Consumer<String> broken = name -> System.out.println(greeting + name); // COMPILE ERROR

Function<String, Integer> parse = Integer::parseInt;        // static
Supplier<String> upper = "hello"::toUpperCase;              // bound instance
Function<String, String> toUpper = String::toUpperCase;     // unbound instance
Supplier<List<String>> factory = ArrayList::new;            // constructor

Function<Integer, Integer> doubleIt = x -> x * 2;
Function<Integer, Integer> addTen = x -> x + 10;

// andThen: apply first, then second → (5*2)+10 = 20
doubleIt.andThen(addTen).apply(5);

// compose: apply second first, then first → (5+10)*2 = 30
doubleIt.compose(addTen).apply(5);

Predicate<Integer> isPositive = n -> n > 0;
Predicate<Integer> isEven = n -> n % 2 == 0;

Predicate<Integer> positiveAndEven = isPositive.and(isEven);   // AND
Predicate<Integer> positiveOrEven = isPositive.or(isEven);     // OR
Predicate<Integer> isOdd = isEven.negate();                    // NEGATE

// Complex chain
Predicate<Integer> complex = isPositive.and(isEven).and(n -> n < 100);
complex.test(42);  // true
complex.test(102); // false

Consumer<String> log = s -> System.out.println("LOG: " + s);
Consumer<String> save = s -> database.save(s);
Consumer<String> logAndSave = log.andThen(save);

Optional<String> present = Optional.of("Hello");       // throws NPE if null
Optional<String> nullable = Optional.ofNullable(name); // safe for null
Optional<String> empty = Optional.empty();

Optional<String> name = Optional.of("john doe");

// map — transform if present
Optional<String> upper = name.map(String::toUpperCase); // Optional["JOHN DOE"]

// flatMap — avoids Optional<Optional<T>>
Optional<String> city = findUser(id)
    .flatMap(User::getAddress)
    .flatMap(Address::getCity);

// filter — keep only if predicate matches
Optional<String> longName = name.filter(n -> n.length() > 3);

optional.orElse("default");                               // always evaluated
optional.orElseGet(() -> computeExpensive());             // lazy — only if empty
optional.orElseThrow(() -> new NotFoundException());      // throw if empty
optional.ifPresent(val -> process(val));                  // action if present
optional.ifPresentOrElse(this::process, this::fallback); // Java 9+

// BAD: Optional as method parameter or class field
public void process(Optional<String> name) { }  // Don't

// BAD: Calling get() without checking
optional.get(); // NoSuchElementException risk

// GOOD: Optional only as return type
public Optional<User> findUserById(Long id) { ... }

names.stream()
     .filter(n -> n.startsWith("A"))    // keep matching
     .map(String::toUpperCase)          // transform 1:1
     .flatMap(Collection::stream)       // flatten nested
     .sorted()                          // natural order
     .distinct()                        // remove duplicates
     .limit(10)                         // cap at N
     .skip(1)                           // skip first N
     .peek(System.out::println);        // debug only

stream.collect(Collectors.toList());              // accumulate
stream.forEach(System.out::println);              // side effect
numbers.stream().reduce(0, Integer::sum);         // combine all
stream.count();                                   // count elements
stream.findFirst();                               // Optional<T>
stream.anyMatch(predicate);                       // boolean
stream.max(Comparator.naturalOrder());            // Optional<T>

List<List<String>> nested = List.of(List.of("a","b"), List.of("c","d"));
List<String> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList()); // [a, b, c, d]

// toList / toSet / toMap
Map<Long, Employee> byId = employees.stream()
    .collect(Collectors.toMap(Employee::getId, Function.identity()));

// joining
String csv = names.stream().collect(Collectors.joining(", ")); // "Alice, Bob"

// groupingBy
Map<Department, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

// groupingBy with downstream
Map<Department, Long> countByDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));

// partitioningBy — split into true/false
Map<Boolean, List<Employee>> split = employees.stream()
    .collect(Collectors.partitioningBy(e -> e.getSalary() > 100000));

// reducing
Optional<Employee> highest = employees.stream()
    .collect(Collectors.reducing(BinaryOperator.maxBy(
        Comparator.comparingDouble(Employee::getSalary))));

// summarizingDouble — stats in one pass
DoubleSummaryStatistics stats = employees.stream()
    .collect(Collectors.summarizingDouble(Employee::getSalary));

Collector<String, StringJoiner, String> custom = Collector.of(
    () -> new StringJoiner(", ", "[", "]"),  // supplier
    StringJoiner::add,                        // accumulator
    StringJoiner::merge,                      // combiner (parallel)
    StringJoiner::toString                    // finisher
);
Stream.of("a", "b", "c").collect(custom); // "[a, b, c]"

// Default: uses common ForkJoinPool (parallelism = availableProcessors - 1)
// Custom pool for isolation:
ForkJoinPool pool = new ForkJoinPool(8);
List<Result> results = pool.submit(() ->
    data.parallelStream()
        .map(this::process)
        .collect(Collectors.toList())
).get();
pool.shutdown();

// BUG: Shared mutable state — race condition
List<Integer> results = new ArrayList<>();
numbers.parallelStream().map(n -> n * 2).forEach(results::add); // WRONG

// FIX: Use collect()
List<Integer> results = numbers.parallelStream()
    .map(n -> n * 2).collect(Collectors.toList()); // SAFE

// BUG: Non-associative operation
numbers.parallelStream().reduce(0, (a, b) -> a - b); // Wrong results!

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public Money add(Money other) {
        return new Money(this.amount.add(other.amount), this.currency); // new object
    }
}

// Java 16+ Records — immutable by default
public record Point(int x, int y) {
    public Point translate(int dx, int dy) { return new Point(x + dx, y + dy); }
}

// Unmodifiable collections (Java 9+)
List<String> list = List.of("a", "b", "c");
Map<String, Integer> map = Map.of("key", 1);

// PURE — safe for parallel streams, cacheable, easy to test
Function<Integer, Integer> square = x -> x * x;

// IMPURE — depends on external state
Function<Integer, Integer> addRandom = x -> x + new Random().nextInt();