Extract a list of all employee names from the employee list

• Stream.map(Function) applies a one-argument function to every element, producing a new stream of transformed values.
• Method reference Employee::getName is preferred over the lambda e -> e.getName() when simply calling an existing getter.
• One-to-one relationship: every input element produces exactly one output element.
• Terminal collector collect(Collectors.toList()) or Java 16+ toList() materialises the stream.
• The source collection is never modified; map produces a brand-new stream.

What does map() do?

The map method on a stream takes a Function and applies it to every element, transforming type T into type R. For name extraction the function takes an Employee and returns its name String, so map changes the stream's element type from Employee to String. The relationship is strictly one-to-one: every input produces exactly one output, so the output stream has the same number of elements as the input.

How do you extract employee names with map()?

You can write the function as a lambda e -> e.getName() or, more concisely, as a method reference Employee::getName. The method reference is preferred when it simply calls an existing method, because it is shorter and signals intent clearly.

package com.bank.hr;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;

public class ExtractNames {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
            new Employee("Rajesh",  "Loans",   new BigDecimal("95000")),
            new Employee("Priya",   "IT",      new BigDecimal("120000")),
            new Employee("Amit",    "Finance", new BigDecimal("85000")),
            new Employee("Kavita",  "Loans",   new BigDecimal("78000")));

        // Using method reference
        List<String> names = staff.stream()
            .map(Employee::getName)
            .collect(Collectors.toList());

        System.out.println(names);
    }
}

[Rajesh, Priya, Amit, Kavita]

How is map() different from flatMap()?

| Feature | map() | flatMap() |
|---|---|---|
| Relationship | One-to-one | One-to-many |
| Return type of function | Single value R | Stream |
| Flattening | No | Yes, merges inner streams |
| Use case | Extract a field | Expand nested collections |

// map: one Employee -> one String (name)
staff.stream().map(Employee::getName);

// flatMap: one Department -> many Employees
departments.stream().flatMap(d -> d.getEmployees().stream());

What are common mistakes?

Mistake: trying to use map when the function returns a collection, then wondering why the result is a list of lists.

// WRONG: map returns Stream<List<String>>, not Stream<String>
List<List<String>> nested = departments.stream()
    .map(Department::getEmployeeNames)   // each dept returns a List<String>
    .collect(Collectors.toList());       // List<List<String>>

// CORRECT: use flatMap to flatten
List<String> flat = departments.stream()
    .flatMap(d -> d.getEmployeeNames().stream())
    .collect(Collectors.toList());       // List<String>

What about Java 16+ toList()?

Java 16 introduced Stream.toList() as a convenience terminal operation that returns an unmodifiable list.

// Java 8-15
List<String> names = staff.stream()
    .map(Employee::getName)
    .collect(Collectors.toList());   // mutable ArrayList

// Java 16+
List<String> names = staff.stream()
    .map(Employee::getName)
    .toList();                       // unmodifiable list

The key difference is that toList() returns an unmodifiable list, so calling names.add("New") throws UnsupportedOperationException. Use collect(Collectors.toList()) when you need to mutate the result.

What about null safety?

If any employee's name could be null, the map itself does not fail, but downstream operations such as sorting or joining might throw a NullPointerException.

// Guard: filter nulls before downstream operations
List<String> safeNames = staff.stream()
    .map(Employee::getName)
    .filter(java.util.Objects::nonNull)
    .collect(Collectors.toList());

What about chaining map with other operations?

map is an intermediate operation, so it can be chained freely with filter, sorted, and other operations in a single pipeline.

// Extract names of Loans department employees, sorted
List<String> loanNames = staff.stream()
    .filter(e -> "Loans".equals(e.getDepartment()))
    .map(Employee::getName)
    .sorted()
    .collect(Collectors.toList());

System.out.println(loanNames);

[Kavita, Rajesh]

What should a senior engineer know?

• map is lazy: it does not execute until a terminal operation triggers the pipeline.
• map preserves encounter order on ordered streams, so the output list has the same order as the input.
• For primitive results use mapToInt, mapToLong, or mapToDouble to avoid boxing overhead.
• The source collection is never modified; map produces a brand-new stream, making it safe for concurrent reads.

What are common interview follow-up questions?

• "What is the difference between map and flatMap?" map is one-to-one; flatMap is one-to-many with flattening.
• "Does map modify the source list?" No, it produces a new stream.
• "When would you use mapToInt instead of map?" When the result is a primitive int, to avoid boxing overhead.