Lambda Expressions & Streams

What Are Lambdas and Streams?

Introduced in Java 8 (2014), lambdas and the Stream API represent the most significant shift in how Java code is written since the language was created. Together they bring functional programming into a traditionally object-oriented language.

A lambda expression is an anonymous function — a block of behaviour you can pass around as a value, store in a variable, or hand to a method. Before Java 8, passing behaviour required anonymous classes: 6 lines of boilerplate for 1 line of logic.

The Stream API is a pipeline model for processing sequences of data. Instead of writing explicit loops that mutate state, you declare what you want — filter this, transform that, collect the results — and the Stream handles the how.

// BEFORE Java 8: anonymous class for sorting — 6 lines for 1 idea
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

// AFTER: lambda — 1 line, same result
names.sort((s1, s2) -> s1.compareTo(s2));

// EVEN BETTER: method reference — reads like English
names.sort(String::compareTo);

// BEFORE: imperative loop — mutable state, hard to parallelise
List<String> result = new ArrayList<>();
for (User user : users) {
    if (user.isActive() && user.getAge() >= 18) {
        result.add(user.getName().toUpperCase());
    }
}
Collections.sort(result);

// AFTER: stream pipeline — declarative, composable, parallelisable
List<String> result = users.stream()
    .filter(User::isActive)
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

Lambda Expressions

Syntax

// (parameters) -> expression   OR   (parameters) -> { statements; }

() -> System.out.println("hello")      // no params, expression body
x -> x * x                              // one param, parens optional
(x, y) -> x + y                         // multiple params
(x, y) -> { int s = x + y; return s; } // block body needs return
(String s) -> s.length()               // explicit type (usually inferred)

Variable capture — effectively final

int multiplier = 3;  // effectively final — never reassigned

List<Integer> result = numbers.stream()
    .map(n -> n * multiplier)  // ✅ captures effectively final variable
    .collect(Collectors.toList());

// ❌ This breaks it:
multiplier = 5;  // now NOT effectively final → compile error in lambda above

// Why the restriction: the lambda may run on a different thread.
// Capturing mutable state would require synchronisation or volatile.
// Java chose the clean solution: capture only immutable data.

// Workaround when you need mutation: use an AtomicInteger or collect results
AtomicInteger counter = new AtomicInteger(0);
names.stream()
    .filter(n -> n.startsWith("A"))
    .forEach(n -> counter.incrementAndGet());  // ✅ object ref is final; state is mutable

Functional Interfaces

A lambda expression is an implementation of a functional interface — any interface with exactly one abstract method (SAM). The compiler infers which interface from the context.

// java.util.function — the core four

// Predicate<T>: T → boolean — use for filtering/testing
Predicate<String> isLong     = s -> s.length() > 5;
Predicate<String> isNotBlank = Predicate.not(String::isBlank); // Java 11+
isLong.and(isNotBlank).test("hello world");  // true — composable
isLong.negate().test("hi");                  // true

// Function<T,R>: T → R — use for transformation
Function<String, Integer> length  = String::length;
Function<String, String>  trimmed = String::strip;
Function<String, Integer> combined = trimmed.andThen(length);  // compose

// Consumer<T>: T → void — use for side effects (logging, saving)
Consumer<User> saveUser = userRepo::save;
Consumer<User> logUser  = u -> log.info("Saved: {}", u.getName());
saveUser.andThen(logUser).accept(newUser);  // save then log

// Supplier<T>: () → T — use for lazy/deferred creation
Supplier<Connection> lazyConn = dataSource::getConnection;
// Connection not opened until lazyConn.get() is called

// Other useful types:
BiFunction<String, Integer, String> repeat = (String::repeat);
UnaryOperator<String>  upper  = String::toUpperCase;  // T → T
BinaryOperator<Integer> max   = Integer::max;          // (T, T) → T

Method references — four kinds

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

// 2. Bound instance:  object::instanceMethod  (specific object)
Consumer<String> print = System.out::println;

// 3. Unbound instance: ClassName::instanceMethod (receiver is first param)
Function<String, String> upper = String::toUpperCase;  // s -> s.toUpperCase()
Comparator<String>    cmp   = String::compareToIgnoreCase;

// 4. Constructor:     ClassName::new
Function<String, StringBuilder> build = StringBuilder::new;
List<User> users = names.stream().map(User::new).toList();

The Stream Pipeline

/*
 *  SOURCE → INTERMEDIATE OPERATIONS (lazy) → TERMINAL OPERATION
 *
 *  List/Set/Map  filter()      collect()
 *  Array         map()         reduce()
 *  Stream.of()   flatMap()     forEach()
 *  IntStream     sorted()      count()
 *  Files.lines() distinct()    findFirst()
 *                limit/skip    anyMatch/allMatch
 *                peek()        toList() Java 16+
 *
 *  Nothing runs until the terminal operation is called.
 */

Intermediate operations

List<String> names = List.of("Alice", "Bob", "Charlie", "Alice");

names.stream().filter(s -> s.startsWith("A"));          // [Alice, Alice]
names.stream().map(String::toUpperCase);                // [ALICE, BOB, CHARLIE, ALICE]
names.stream().distinct();                               // [Alice, Bob, Charlie]
names.stream().sorted();                                 // alphabetical
names.stream().sorted(Comparator.comparingInt(String::length)); // by length
names.stream().limit(2);                                // [Alice, Bob]
names.stream().skip(2);                                 // [Charlie, Alice]

// flatMap: each element → multiple elements, then flatten
List<List<String>> nested = List.of(List.of("a","b"), List.of("c","d"));
nested.stream().flatMap(List::stream);                 // [a, b, c, d]

// mapToInt/mapToLong/mapToDouble — avoid boxing overhead
names.stream().mapToInt(String::length).sum();         // primitive IntStream

// Java 9+
Stream.of(1,2,3,4,5).takeWhile(n -> n < 4);           // [1, 2, 3]
Stream.of(1,2,3,4,5).dropWhile(n -> n < 4);           // [4, 5]

Terminal operations

List<Integer> nums = List.of(1, 2, 3, 4, 5);

// Collect
nums.stream().collect(Collectors.toList());   // mutable list
nums.stream().toList();                         // unmodifiable list (Java 16+)
nums.stream().collect(Collectors.toSet());

// Reduction
nums.stream().reduce(0, Integer::sum);         // 15
nums.stream().mapToInt(Integer::intValue).sum(); // 15 — no Optional

// Search (short-circuit — stops as soon as result is found)
nums.stream().findFirst();                      // Optional[1]
nums.stream().filter(n -> n > 3).findFirst(); // Optional[4]
nums.stream().anyMatch(n -> n > 3);           // true
nums.stream().allMatch(n -> n > 0);           // true
nums.stream().noneMatch(n -> n < 0);          // true

// Count / statistics
nums.stream().count();                          // 5
nums.stream().max(Integer::compare);          // Optional[5]
nums.stream().mapToInt(Integer::intValue).average(); // OptionalDouble[3.0]

Collectors — Grouping and Aggregating

record Person(String name, int age, String dept) {}

List<Person> people = List.of(
    new Person("Alice", 25, "Eng"), new Person("Bob", 30, "Eng"),
    new Person("Carol", 35, "Mkt"), new Person("Dan", 28, "Mkt")
);

// Joining strings
people.stream().map(Person::name)
    .collect(Collectors.joining(", ", "[", "]"));   // [Alice, Bob, Carol, Dan]

// groupingBy → Map<K, List<V>>
Map<String, List<Person>> byDept = people.stream()
    .collect(Collectors.groupingBy(Person::dept));

// groupingBy with downstream collector
Map<String, Long>   countByDept = people.stream()
    .collect(Collectors.groupingBy(Person::dept, Collectors.counting()));

Map<String, Double> avgAge = people.stream()
    .collect(Collectors.groupingBy(Person::dept,
                                    Collectors.averagingInt(Person::age)));

Map<String, Optional<Person>> oldest = people.stream()
    .collect(Collectors.groupingBy(Person::dept,
                                    Collectors.maxBy(Comparator.comparingInt(Person::age))));

// partitioningBy → Map<Boolean, List> (binary split)
Map<Boolean, List<Person>> senior = people.stream()
    .collect(Collectors.partitioningBy(p -> p.age() >= 30));
// {false=[Alice, Dan], true=[Bob, Carol]}

// toMap — watch out for duplicate keys (throws by default)
Map<String, Integer> nameToAge = people.stream()
    .collect(Collectors.toMap(Person::name, Person::age));

// toMap with merge function for duplicates
Map<String, Integer> maxAgeByDept = people.stream()
    .collect(Collectors.toMap(Person::dept, Person::age, Integer::max));

Parallel Streams

One word converts a stream to parallel: .parallelStream() or .parallel(). The stream splits the data, processes chunks on the ForkJoinPool.commonPool(), and merges results. It is not always faster — the overhead of splitting and merging exceeds the benefit for small datasets.

// CPU-bound work on large data: parallel wins
long sum = IntStream.rangeClosed(1, 10_000_000)
    .parallel()
    .asLongStream()
    .sum();

// ✅ Use parallel when:
//   - Large dataset (tens of thousands+ elements)
//   - CPU-intensive operation per element
//   - Stateless, independent operations
//   - Source is easily splittable (ArrayList, arrays — NOT LinkedList)

// ❌ Avoid parallel when:
//   - Small dataset (overhead > gain)
//   - I/O-bound work (blocks ForkJoinPool threads — starves other parallel streams)
//   - Order matters AND you can't afford forEachOrdered() cost
//   - Shared mutable state (race conditions)

// Custom pool — avoid starving common pool with I/O
ForkJoinPool pool = new ForkJoinPool(4);
long result = pool.submit(() ->
    data.parallelStream().mapToLong(Item::computeExpensive).sum()
).get();
pool.shutdown();

Common Pitfalls

Stream<String> stream = Stream.of("a", "b");
stream.forEach(System.out::println);  // ✅
stream.forEach(System.out::println);  // ❌ IllegalStateException: stream already consumed

// ✅ Collect first if you need to iterate multiple times
List<String> list = Stream.of("a", "b").toList();

// ❌ Nothing prints — peek() is lazy, no terminal op
names.stream()
    .filter(n -> n.length() > 3)
    .peek(System.out::println);  // never executes!

// ✅ Add terminal operation
names.stream()
    .filter(n -> n.length() > 3)
    .peek(System.out::println)
    .toList();

// ❌ forEach adding to external list — not thread-safe with parallel
List<String> result = new ArrayList<>();
names.stream().filter(n -> n.length() > 3).forEach(result::add);

// ✅ Use collect() — works correctly with both sequential and parallel
List<String> result = names.stream()
    .filter(n -> n.length() > 3)
    .collect(Collectors.toList());

List<String> names = Arrays.asList("Alice", null, "Bob");
names.stream().map(String::toUpperCase).toList();  // ❌ NullPointerException

// ✅ Filter nulls explicitly
names.stream()
    .filter(Objects::nonNull)
    .map(String::toUpperCase)
    .toList();

Senior Topics: Advanced Patterns

Real-world pipeline: order processing

// Revenue per category, using BigDecimal for money
Map<String, BigDecimal> revenueByCategory = orders.stream()
    .flatMap(o -> o.items().stream())            // Order → OrderItem
    .collect(Collectors.groupingBy(
        OrderItem::category,
        Collectors.reducing(
            BigDecimal.ZERO,
            item -> item.price().multiply(BigDecimal.valueOf(item.qty())),
            BigDecimal::add
        )
    ));

// High-value customers (total spent > 1000)
List<String> whales = orders.stream()
    .collect(Collectors.groupingBy(Order::customerId,
                                   Collectors.summingDouble(Order::total)))
    .entrySet().stream()
    .filter(e -> e.getValue() > 1000)
    .map(Map.Entry::getKey)
    .toList();

Custom Collector

// When built-in collectors aren't enough: implement Collector<T, A, R>
// T=input, A=accumulator, R=result
Collector<String, StringJoiner, String> csvCollector =
    Collector.of(
        () -> new StringJoiner(","),  // supplier
        StringJoiner::add,              // accumulator
        StringJoiner::merge,            // combiner (for parallel)
        StringJoiner::toString          // finisher
    );

String csv = Stream.of("Alice", "Bob", "Carol").collect(csvCollector);
// "Alice,Bob,Carol"

Lazy evaluation — performance implications

// Intermediate operations fuse into a single pass over the data.
// This pipeline does NOT create 3 intermediate lists:
long count = IntStream.rangeClosed(1, 1_000_000)
    .filter(n -> n % 2 == 0)   // \
    .filter(n -> n % 3 == 0)   //  fused into one pass
    .map(n -> n * n)             // /
    .count();

// Short-circuit: stops as soon as result is found — never touches the rest
Optional<Integer> first = IntStream.rangeClosed(1, 1_000_000)
    .filter(n -> n % 17 == 0)
    .findFirst();  // stops at 17 — doesn't process 999,983 more elements

// Order operations from most restrictive to least:
// filter early → fewer elements for expensive map/sorted
users.stream()
    .filter(User::isActive)        // cheap: boolean check, eliminates many
    .filter(u -> u.age() >= 18)   // cheap: int comparison
    .map(User::loadFullProfile)    // expensive: DB call — only on survivors
    .sorted(Comparator.comparing(User::score))
    .limit(10)
    .toList();

Interview Questions