Stream Practice: Employee Analysis

groupingBy(Employee::getCity) produces Map<City, List<Employee>>; combine with filter for conditional grouping and downstream collectors for counts, names, or nested grouping.

groupingBy(gender, counting()) for org-wide count; nested groupingBy(dept, groupingBy(gender, counting())) for per-department; partitioningBy for binary male/female split.

Use groupingBy(Employee::getGender, averagingInt(Employee::getAge)) for average age by gender, and nest groupingBy three levels deep for per-department per-gender breakdowns.

Use Stream.max(comparingInt(Employee::getAge)) for the oldest overall, filter(female).min(comparingInt(age)) for the youngest female, and groupingBy(department, maxBy(comparingInt(age))) for per-department extremes.

Group by department with counting(), then stream the entrySet and find max by value to get the department with the most employees.

Use map(getSalary).max(naturalOrder()) for the highest salary, sorted(reverseOrder()).distinct().skip(n-1).findFirst() for the Nth-highest unique salary, and sorted(comparing(salary).reversed()).limit(3) for the top 3 earners.

Use Stream.concat to combine two lists, then Collectors.toMap with a merge function to handle duplicate employee IDs: keep-existing, keep-incoming, or deep-merge specific fields.

Use distinct() for value-based dedup via equals/hashCode, and the distinctByKey utility pattern with ConcurrentHashMap for field-based dedup without modifying equals.

Collectors.summarizingDouble(Employee::getSalary) produces a DoubleSummaryStatistics object that tracks count, sum, min, max, and average of salaries in a single pass through the stream.

Collectors.toUnmodifiableList() collects stream results into an immutable list that throws UnsupportedOperationException on any modification attempt.

Collectors.teeing feeds every stream element to two downstream collectors simultaneously and merges their results into one value, computing both min and max salary in a single pass.

Collectors.joining(", ", "[", "]") concatenates a Stream of names into a single string like "[Rajesh, Priya, Amit]" with commas between names and brackets around the whole result.

Use skip((page-1) * pageSize) to jump past earlier pages and limit(pageSize) to cap the result, implementing offset-based pagination on an ordered stream.

Stream.concat(a, b) joins two streams into one (all of a then all of b), and you follow with toMap or distinctByKey to deduplicate by employee ID.

Use groupingBy(dept, summarizingDouble(salary)) to produce a Map of DoubleSummaryStatistics per department, then format the count, sum, min, max, and average from each statistics object.

Sum salaries per department, find the department with the highest total, then find the employee with the highest salary in that department.

Compute a cutoff date with LocalDate.now().minusYears(5) and filter employees whose joining date is on or after that cutoff using !isBefore.

Use stream().max(Comparator.comparing(Employee::getJoinDate)) to find the employee with the latest joining date.

ChronoUnit.DAYS.between(dateA, dateB) returns the total number of days between two LocalDate values as a long, with correct leap-year handling.

DateTimeFormatter.ofPattern("dd-MMM-yyyy") formats a LocalDate like 15-Jan-2021, and you apply it in a stream with map(e -> e.getJoinDate().format(formatter)).

Filter the stream with a predicate that calls String.startsWith("A") on each employee's name to keep only names beginning with the letter A.

Filter employees whose birth date's month matches LocalDate.now().getMonth() to find everyone with a birthday this month.

Compute average salary per department with `groupingBy` and `averagingDouble`, then sort the entrySet descending by value and `limit(3)` for the top 3.

Compute department averages with `groupingBy` + `averagingDouble`, then filter employees whose salary exceeds their department's average.

Group by name with counting() to build a frequency map, then filter entries where the count exceeds one to identify duplicate names.

Build a Set of excluded departments and filter with the negated contains check to keep employees whose department is not in the set.

Group by department with summarizingInt(age), compute max - min for each department's statistics, then find the department with the largest range.

Filter employees under retirement age, then find the one with the highest age (closest to 60) using max(comparingInt(age)).

Group by city with counting(), then find the max entry by value to identify the most common city.

Group by the year component of the joining date with counting(), then find the max entry by value.

Use groupingBy(gender, minBy(comparingInt(age))) to find the youngest male and youngest female employee in a single pass.

Nest groupingBy(dept, groupingBy(gender, counting())) to get per-department gender counts, then compute the male-to-female ratio from the nested map.

Map each employee to a new Employee with salary adjusted by the department-specific raise percentage, using a policy Map for flexible rate lookup.

Group by department with averagingInt(age), then filter the resulting map entries where the average exceeds 35.

Convert the string to an IntStream with chars(), filter for letters, partition by vowel membership, and count each partition.

Group employees by birth month using `groupingBy(getBirthDate().getMonth())`, then keep only groups with more than one member to find birthday-month sharing.

Group employees by salary with `groupingBy(getSalary)`, then filter groups with more than one employee to find same-salary pairs.

Running sum requires mutable state between elements, which streams discourage; use AtomicInteger for a sequential hack or Arrays.parallelPrefix for a proper prefix-sum.

Group by department with averagingDouble(salary) as the downstream, then stream the entrySet and find max by value to identify the department with the highest average salary.

Group by department with summingDouble(salary) as the downstream, then find max by value on the entrySet to identify the highest-spending department.

Find the second-highest unique salary amount using distinct-sort-skip-findFirst, then filter all employees earning that amount to handle ties.

Map to salary, distinct to collapse duplicates, sort descending, skip(n-1), and findFirst to get the Nth-highest unique salary.

First compute the average salary per department with groupingBy + averagingDouble, then filter all employees whose salary exceeds their department's average.