Stream: map & Transform

map transforms each element one-to-one (N to N, intermediate, lazy); reduce aggregates all elements into one value (N to 1, terminal, eager): map shapes data, reduce summarises it.

`Collectors.toMap(Employee::getId, e -> e)` builds a `Map<Long, Employee>`, and the third argument, a merge function, decides which employee survives when two share the same id.

`toMap(Employee::getId, Employee::getName, (a, b) -> a, LinkedHashMap::new)` builds an id-to-name map whose iteration order matches the order the employees appeared in the stream.

`employees.stream().mapToInt(Employee::getAge)` produces an `IntStream` whose `sum()`, `average()`, `min()`, and `max()` compute age statistics directly on primitive ints without boxing.

`collectingAndThen(toList(), Collections::unmodifiableList)` collects the stream into a list and then applies a finishing step that wraps it as read-only, all in one pipeline.

LocalDate.parse("2020-01-15") creates a date, and ChronoUnit.YEARS.between(join, now) gives completed tenure years.

`map` transforms each element into something else, one in and one out, producing a new stream of the results.

`map(String::toUpperCase)` turns every name into its capitalised form, leaving the originals unchanged.

andThen chains functions left to right: extract the name, then uppercase it.

`Collectors.joining(", ")` glues a stream of strings into one comma-separated string.

`employees.stream().mapToInt(Employee::getAge)` gives an `IntStream` of ages on which `sum()` returns an `int` and `average()`, `max()`, `min()` return optionals.

`intStream.boxed()` turns an `IntStream` into a `Stream<Integer>`, wrapping each primitive `int` in an `Integer` so you can use object-stream operations like `collect(Collectors.toList())`.

`map` to the field, then `distinct()` to drop repeats, giving each unique value once.

`map` can build a new, slimmer object per element, exposing only the fields a layer should see.

`map(String::length)` turns each name into its character count.

`map` can format each element into a readable label by combining several of its fields into one string.

`map` can parse each raw line by splitting it and constructing a typed object from the pieces.

`map` can serialise each object into a CSV row by joining its fields with commas.

Map.merge(key, value, Integer::sum) adds values on key clashes when combining two maps.

Stream entrySet and collect with toMap, keeping the key and replacing each list value with its size cast to Long.

entrySet().stream().max(comparingByValue()) finds the entry with the biggest value; map to its key for the answer.

summaryStatistics() computes count, sum, min, max, and average together in a single traversal of the stream.

Collectors.toMap(Employee::getId, Employee::getName) turns a list of employees into an id-to-name lookup map.

The third argument of toMap is a merge function: Double::max keeps the higher salary when two employees share the same name.

toMap(dept, e->e, BinaryOperator.maxBy(comparingDouble(salary))) keeps the highest-paid employee per department with no Optional wrapper.

groupingBy(Employee::getDepartment, counting()) produces a department-to-head-count map in a single pass.

Stream entries, flatMap the name lists into name-department pairs, and toMap(name, dept) to invert the map.

Count chars into a LinkedHashMap preserving first-seen order, then pick the first entry with count 1.

chars().mapToObj(c -> (char) c).collect(groupingBy(c -> c, counting())) tallies each character's frequency.

Collectors.joining(", ") concatenates stream elements into one comma-separated string, placing the delimiter only between elements.

`toMap(Transaction::getAccountId, Transaction::getAmount, BigDecimal::add)` builds account id to total balance, and the merge function `BigDecimal::add` sums the amounts of transactions that share an account.

filter(n -> n > threshold) keeps values above the cutoff, then map(String::valueOf) converts each survivor to its decimal string representation.

groupingBy(getGender, averagingDouble(getSalary)) groups employees by gender and computes the average salary per group in a single pass.

Integer::parseInt is a static method reference that parses each numeric string into an int when used in map or mapToInt.