Employee Data Analysis with Streams
Uploaded by
rutujachoudhari32Employee Data Analysis with Streams
Uploaded by
rutujachoudhari32Common questions
Powered by AITo ascertain the different departments available, use the stream API to map the department names and then apply a distinct filter to extract unique departments. This can be achieved with: employeeList.stream().map(Employee::getDepartment).distinct().forEach(System.out::println). This lists all unique department names available in the company .
The employee with the most working experience can be identified by finding the one with the earliest year of joining. This can be achieved with: employeeList.stream().min(Comparator.comparing(Employee::getYearOfJoining)). The result is the employee who joined the earliest, hence having the most working experience within the organization .
To find the average salary of employees in each department using the Java Stream API, you can group employees by their department and then calculate the average salary within each group. This can be implemented using: employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getSalary))). This will return a map where each key is a department and each value is the average salary of employees in that department .
We can determine the number of male and female employees in each department by first filtering the employees based on their department and then grouping them by gender. This can be achieved using the stream API in Java with the following logic: emps.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.groupingBy(Employee::getGender, Collectors.counting()))). This approach allows us to map each department to a secondary map that counts the male and female employees within that department .
You can separate employees based on age using Java's stream partitioning feature: employeeList.stream().collect(Collectors.partitioningBy(e -> e.getAge() <= 25)). This method partitions employees into two groups: one for those who are 25 years or younger and another for those older than 25. It provides a clear division of employees based on the specified age criteria .
To list down departments with the number of employees in each, we can use Java streams to group the employees by their department and then count them. This can be done using: employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting())). This method collects the data into a map where each key is a department name, and the value is the count of employees in that department .
To determine the average and total salary for the entire organization, sum the salaries of all employees and divide by the count of employees for the average salary. For the total salary, use the sum of all employee salaries. This involves: double totalSalary = employeeList.stream().mapToDouble(Employee::getSalary).sum(); double averageSalary = totalSalary / employeeList.size(); This provides the aggregated financial insights into the organization's salary structure .
To determine the number of male and female employees in the Sales team, filter the employee list for those in the Sales department, then group by gender and count. This process is: employeeList.stream().filter(e -> e.getDepartment().equals("Sales")).collect(Collectors.groupingBy(Employee::getGender, Collectors.counting())). This setup provides a count breakdown of male and female employees in the Sales team .
To identify the youngest male employee in the Development department, filter the employee list for males in the Development department, and then find the employee with the minimum age using a comparator. This can be achieved with: employeeList.stream().filter(e -> e.getGender().equals("Male") && e.getDepartment().equals("Development")).min(Comparator.comparing(Employee::getAge)). This will return an Optional<Employee> containing the youngest male employee in the Development department if present .
The highest paid employee can be identified by finding the employee with the maximum salary using a comparator. This can be achieved with: employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary)). This returns an Optional<Employee> object, which contains the employee with the highest salary if present .