Streams and Lambdas in Java

// Functional interface — exactly one abstract method
@FunctionalInterface
interface Transformer<T, R> {
    R transform(T input);
}

// Lambda syntax: (params) -> expression
Transformer<String, Integer> length = s -> s.length();
Transformer<Integer, Integer> square = n -> n * n;

// Multi-line lambda — use a block body
Transformer<String, String> shout = s -> {
    String upper = s.toUpperCase();
    return upper + "!";
};

// Built-in functional interfaces from java.util.function
// Predicate<T>    — T -> boolean
// Function<T,R>   — T -> R
// Consumer<T>     — T -> void
// Supplier<T>     — () -> T
// BiFunction<T,U,R> — (T,U) -> R
// UnaryOperator<T> — T -> T (extends Function<T,T>)

import java.util.function.*;

Predicate<String>      isLong    = s -> s.length() > 5;
Function<String, Integer> toLen  = String::length;     // method reference
Consumer<String>       printer   = System.out::println;
Supplier<List<String>> listMaker = ArrayList::new;

isLong.test("Hello");       // false
isLong.test("Hello World"); // true
toLen.apply("Java");        // 4
printer.accept("Hi");       // prints "Hi"

// Method reference — shorthand for a lambda that just calls a method
// Four kinds:

// 1. Static method:   ClassName::staticMethod
Function<String, Integer> parse = Integer::parseInt;

// 2. Instance method on arbitrary instance:  ClassName::instanceMethod
Function<String, String>  upper = String::toUpperCase;
Function<String, Integer> len   = String::length;

// 3. Instance method on a specific instance:  instance::method
String prefix = "Hello, ";
Function<String, String> greet = prefix::concat;

// 4. Constructor:  ClassName::new
Supplier<ArrayList<String>>  newList   = ArrayList::new;
Function<Integer, int[]>     newArray  = int[]::new;

// Equivalent lambdas for comparison
// Integer::parseInt  ≡  s -> Integer.parseInt(s)
// String::toUpperCase ≡  s -> s.toUpperCase()
// prefix::concat      ≡  s -> prefix.concat(s)

import java.util.stream.*;
import java.util.*;

List<String> names = List.of("Priya", "Rahul", "Anita", "Zara", "Priya");

// A stream pipeline: source → intermediate ops → terminal op
List<String> result = names.stream()           // 1. source
    .distinct()                                 // 2. intermediate (lazy)
    .filter(n -> n.length() > 4)               // 2. intermediate (lazy)
    .map(String::toUpperCase)                  // 2. intermediate (lazy)
    .sorted()                                  // 2. intermediate (lazy)
    .collect(Collectors.toList());             // 3. terminal — executes pipeline
// ["ANITA", "PRIYA", "RAHUL"]

// Nothing runs until the terminal operation

// Common terminal operations
long count   = names.stream().filter(n -> n.startsWith("P")).count();
boolean any  = names.stream().anyMatch(n -> n.length() > 5);
boolean all  = names.stream().allMatch(n -> n.length() > 2);
Optional<String> first = names.stream().findFirst();
String joined = names.stream().collect(Collectors.joining(", "));

// reduce — combine all elements into one
int total = IntStream.rangeClosed(1, 100).sum();   // 5050
int product = Stream.of(1, 2, 3, 4, 5)
    .reduce(1, (a, b) -> a * b);   // 120