Functional Programming Lambda – Functional Interfaces, Streams, map, filter, reduce

This post is a conceptual overview of functional programming, including exam questions and key takeaways.

In a Nutshell

Functional programming emphasizes computation through functions rather than state mutations. Lambda expressions are inline function literals that bind to the Java runtime via Functional Interfaces—types with exactly one abstract method.

Core Concepts

A lambda expression captures anonymous behavior with parameters, a body, and an optional return type. The type is inferred from the target context—a Functional Interface such as Predicate, Function, Consumer, or Supplier. These interfaces enable Higher Order Functions, where functions are passed as values, returned, or stored. Key principles include Pure Functions, where consistent input always produces deterministic output without side effects; Referential Transparency, which reduces coupling and makes testing and parallelization easier; and Immutability, which strengthens thread safety and simplifies reasoning about code.

Exam-Relevant Topics

• Lambda syntax: parameter list, arrow operator, body, and target type inference via Functional Interface
• Standard interfaces: Function<T,R>, Predicate<T>, Consumer<T>, Supplier<T>, UnaryOperator<T>, BinaryOperator<T>
• Streams: map, filter, flatMap, reduce, collect—explain each briefly and justify typical complexity
• IHK curriculum: imperative vs. functional paradigms, avoiding side effects, benefits for testability and parallelization
• Method references: ClassName::staticMethod, instance::method, Constructor::new
• Security: no hidden side effects in lambdas, thread safety through immutability
• Business value: less boilerplate, clearer data flow, better maintainability, potentially lower defect rates
• Documentation: document the function contract, input domain, side effects, concurrency properties, and complexity

Core Components

1. Lambda expression syntax: parameters, body, return value
2. Functional Interface with exactly one abstract method (SAM)
3. Method references as a compact alternative notation
4. Higher Order Functions: functions as parameters or return values
5. Pure Functions and side effects: testability, determinism
6. Immutability and thread safety
7. Stream pipelines: lazy evaluation, short-circuit operators
8. Closures and effectively final in Java
9. Optional and error patterns: Optional, Try, Either concepts
10. Parallel Streams: data independence, boxed vs. primitive streams

Practical Example

// Java: filtering and transforming data with lambdas and streams
List<String> names = List.of("Mila", "Tom", "Amir", "Mara")
List<Integer> lengths = names.stream()
.filter(n -> n.startsWith("M"))
.map(String::length)
.sorted()
.toList()

// Custom Functional Interface and lambda
@FunctionalInterface
interface IntOp { int apply(int a, int b) }
IntOp add = (a, b) -> a + b
IntOp max = Math::max
int r1 = add.apply(3, 4) // 7
int r2 = max.apply(5, 9) // 9

Explanation: The stream pipeline demonstrates map, filter, sorted, and toList. The lambdas are pure and side-effect free.

Advantages and Disadvantages

Advantages

• Less boilerplate, clearer declarative style
• Better testability through pure functions
• Simple parallelization thanks to immutability
• High reusability via combinators

Disadvantages

• Learning curve for abstractions like Higher Order Functions
• Harder debugging in pipelines
• Careless variable capture can pin memory
• Java limitations: effectively final variables and type erasure

Common Exam Questions (with Quick Answers)

1. What is a lambda expression in Java and how is its type determined? An anonymous function literal whose type is inferred from the target context—a Functional Interface with one abstract method.

2. Name four core Functional Interfaces from java.util.function. Function<T,R>, Predicate<T>, Consumer<T>, Supplier<T>, plus Operator types that map T to T.

3. What’s the difference between writing a method as a lambda versus using a method reference? Method references point directly to existing methods and are equivalent to a lambda but more concise and readable.

4. What does “effectively final” mean in the context of closures? Local variables captured by lambdas cannot be reassigned after initialization, allowing the JVM to capture them safely.

5. What is Referential Transparency and why does it matter? An expression can be replaced by its value without changing program behavior, which promotes testability and reasoning about code.

6. How does reduce work in a stream pipeline? It iteratively combines elements using an associative accumulator and an optional identity value, for example reduce(0, Integer::sum).

7. What are the risks with Parallel Streams? Non-associative accumulators produce incorrect results, and side-effect-laden lambdas are unsafe in parallel execution.

8. How do you model errors in a functional style? Use wrapper types like Optional to represent absence, or Try/Either for success or failure, instead of throwing global exceptions.

9. What’s the difference between an imperative loop and a functional pipeline? Imperative: explicit mutation and control flow. Functional: declarative data transformation, immutability, easier to test.

10. How do Functional Interfaces in Java differ from true function types? Java uses SAM types as a substitute, whereas languages like Kotlin, Scala, and Haskell have native function types with first-class support.

Key Resources

1. https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
2. https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
3. https://en.wikipedia.org/wiki/Functional_programming

Book Recommendation