Functional Interfaces & Method References

Function<String, Integer> length = String::length;
Predicate<String> isEmpty = String::isEmpty;
Consumer<String> printer = System.out::println;
Supplier<String> greeting = () -> "Hello";

System.out.println(length.apply("hello"));  // 5
System.out.println(isEmpty.test(""));         // true

Common follow-ups: What's the difference between Function and UnaryOperator, given both seem to take and return one value?;Why do these interfaces exist as generic interfaces rather than the JDK using raw Object types?

// Static
Function<String, Integer> parse = Integer::parseInt;

// Bound instance (specific object 'str')
String str = "hello";
Supplier<Integer> len = str::length;

// Unbound instance (first param becomes the receiver)
Function<String, Integer> len2 = String::length;  // equivalent to s -> s.length()

// Constructor
Supplier<ArrayList<String>> listMaker = ArrayList::new;

Common follow-ups: How would you write the unbound instance method reference example as an equivalent explicit lambda?;What happens if a method reference is ambiguous between multiple overloaded methods with the same name?

public Supplier<Integer> makeCounter() {
    int count = 0;
    // count++; // if uncommented, would cause a COMPILE ERROR: count is no longer effectively final
    return () -> count;  // captures the VALUE of count (0) at lambda creation time
}

// Workaround for genuine mutable state: use an array or an AtomicInteger as a container
AtomicInteger counter = new AtomicInteger(0);
Runnable increment = counter::incrementAndGet;  // captures the reference, container itself is mutable

Common follow-ups: Why does capturing an instance field (via 'this') not have the same effectively-final restriction that local variables do?;What's the specific mechanism (variable capture into a synthetic final copy) the compiler uses under the hood to implement this?

Function<Integer, Integer> addOne = x -> x + 1;
Function<Integer, Integer> multiplyByTwo = x -> x * 2;

Function<Integer, Integer> addThenMultiply = addOne.andThen(multiplyByTwo);
System.out.println(addThenMultiply.apply(3));  // (3+1)*2 = 8

Function<Integer, Integer> multiplyThenAdd = addOne.compose(multiplyByTwo);
System.out.println(multiplyThenAdd.apply(3));  // (3*2)+1 = 7 -- compose applies multiplyByTwo FIRST

Common follow-ups: How would you chain more than two functions together using andThen() repeatedly?;Does Predicate have similar default methods (and(), or(), negate()) for combining boolean conditions?

@FunctionalInterface
public interface TriFunction<A, B, C, R> {
    R apply(A a, B b, C c);  // built-in Function/BiFunction only support 1 or 2 parameters
}

TriFunction<Integer, Integer, Integer, Integer> sum3 = (a, b, c) -> a + b + c;
System.out.println(sum3.apply(1, 2, 3));  // 6

Common follow-ups: Why does the standard library stop at BiFunction and not provide TriFunction/QuadFunction built in?;How would you design a functional interface whose method needs to declare a checked exception, given standard functional interfaces don't support this?

UnaryOperator<String> toUpper = String::toUpperCase;
UnaryOperator<Integer> square = x -> x * x;

// Equivalent to Function<String, String> and Function<Integer, Integer>, but more semantically clear
UnaryOperator<String> identity = UnaryOperator.identity();  // returns its input unchanged
System.out.println(identity.apply("test"));  // "test"

Common follow-ups: What's the equivalent 'BinaryOperator' interface, and what use case does it serve for combining two same-typed values?;Why does List.replaceAll() specifically require UnaryOperator rather than accepting a general Function?

public static <T, R> Function<T, R> memoize(Function<T, R> function) {
    Map<T, R> cache = new ConcurrentHashMap<>();
    return input -> cache.computeIfAbsent(input, function);
}

Function<Integer, Long> slowFactorial = n -> { /* expensive computation */ return computeFactorial(n); };
Function<Integer, Long> fastFactorial = memoize(slowFactorial);
fastFactorial.apply(20);  // computed and cached
fastFactorial.apply(20);  // returned instantly from cache on second call

Common follow-ups: What's the memory growth risk of an unbounded memoization cache, and how would you add eviction (like an LRU policy)?;Why can computeIfAbsent() with a recursive function cause issues in some JDK versions, and how would you avoid that pitfall?

// Generic version: boxing overhead on every call
Function<Integer, Integer> square1 = x -> x * x;

// Primitive-specialized: no boxing overhead
IntUnaryOperator square2 = x -> x * x;

IntStream.rangeClosed(1, 1_000_000)
    .map(square2)  // IntStream.map() specifically expects IntUnaryOperator, avoiding boxing entirely
    .sum();

Common follow-ups: What specific primitive-specialized interfaces exist for long and double in addition to int?;How much actual performance difference does boxing avoidance make in practice for a typical workload size?

List<String> words = List.of("Hello", "World", "Java");

String concatenated = words.stream()
    .reduce("", (acc, word) -> acc.isEmpty() ? word : acc + " " + word);
System.out.println(concatenated);  // "Hello World Java"

// Equivalent explicit imperative loop, which reduce() replaces declaratively:
// String result = "";
// for (String word : words) { result = result.isEmpty() ? word : result + " " + word; }

Common follow-ups: What's the difference between the two-argument and three-argument overloads of Stream.reduce()?;Why does reduce() require the combiner function to be associative for correct behavior with parallel streams?

Predicate<String> isLongEnough = s -> s.length() >= 8;
Predicate<String> hasDigit = s -> s.chars().anyMatch(Character::isDigit);
Predicate<String> hasUpperCase = s -> s.chars().anyMatch(Character::isUpperCase);

Predicate<String> isStrongPassword = isLongEnough.and(hasDigit).and(hasUpperCase);
System.out.println(isStrongPassword.test("Password1"));  // true

Common follow-ups: How does short-circuit evaluation in and()/or() affect performance when the predicates involve expensive checks?;How would you build a list of predicates and combine them all with and() dynamically at runtime?