Task - Collection - Employee Statistics #57

akash-coded · 2022-03-10T02:59:39Z

akash-coded
Mar 10, 2022
Maintainer

You are given the following blueprint for representing a college Employee:

class Employee
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}

Create six Employee instances:

Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

Create a list of these students called employeeList and write code to do the following operations:

Count the number of employees in each department.
Find out the average salary of male and female employees.
Get the details of the highest-paid employee in the organization from the given list of employees.
Get the average age of each department in an organization.
Find out who is the senior-most employee in the organization in terms of experience.
Get the details of the youngest employee in the organization.
Get the number of employees in each department if you have given a list of employees.
Find out the number of male and female employees in the organization.

Expected Output:

{female=90000.0, male=315000.0}

Optional[Id : 4, Name : Amitabh Singh, age : 35, Gender : male, Department : Admin, Year Of Joining : 2014, Salary : 500000.0]

{Account=31.5, HR=34.0, Admin=31.0}

Optional[Id : 3, Name : Vishal Singhal, age : 34, Gender : male, Department : HR, Year Of Joining : 2013, Salary : 300000.0]

Optional[Id : 5, Name : Vivek Bhati, age : 28, Gender : male, Department : Admin, Year Of Joining : 2017, Salary : 500000.0]

{Account=2, HR=1, Admin=3}

{female=1, male=5}

ujjwal18bit1167 · 2022-03-10T10:06:48Z

ujjwal18bit1167
Mar 10, 2022

package collections;

import java.util.ArrayList;
import java.util.HashMap;

import java.util.Iterator;

class Employee2 {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee2(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class Task2 {
    public static void main(String[] args) {
        Employee2 emp1 = new Employee2(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee2 emp2 = new Employee2(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee2 emp3 = new Employee2(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee2 emp4 = new Employee2(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee2 emp5 = new Employee2(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee2 emp6 = new Employee2(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        ArrayList<Employee2> list = new ArrayList<>();
        list.add(emp1);
        list.add(emp2);
        list.add(emp3);
        list.add(emp4);
        list.add(emp5);
        list.add(emp6);
        HashMap<String, Integer> map = new HashMap<>();
        for (Employee2 emp : list) {

            map.put(emp.department, map.getOrDefault(emp.department, 0) + 1);
        }
        double maleSalarySum = 0, femaleSalarySum = 0;
        int countMales = 0, countFemales = 0;
        for (Employee2 emp : list) {
            if (emp.gender.equals("male")) {
                maleSalarySum += emp.salary;
                countMales++;

            } else {
                femaleSalarySum += emp.salary;
                countFemales++;
            }
        }
        System.out.println("{feamle=" + femaleSalarySum / countFemales + ", male=" +
                maleSalarySum / countMales + "}");

        double maxSalary = Double.MIN_VALUE;
        Employee2 highestPaidEmp = null;
        for (Employee2 emp : list) {

            if (maxSalary < emp.salary) {
                maxSalary = emp.salary;
                highestPaidEmp = emp;
            }
        }
        System.out.println("Optional" + highestPaidEmp);

        double ageSum = 0;
        for (Employee2 emp : list) {
            ageSum += emp.age;

        }

        HashMap<String, ArrayList<Employee2>> departmentMap = new HashMap<>();
        for (Employee2 emp : list) {

            departmentMap.put(emp.department, new ArrayList<>());
        }
        for (Employee2 emp : list) {

            departmentMap.get(emp.department).add(emp);
        }
        // System.out.println(departmentMap);
        HashMap<String, Double> avgAgeMap = new HashMap<>();

        for (String department : departmentMap.keySet()) {
            ArrayList<Employee2> myEmpArrayList = departmentMap.get(department);
            double avgAgeSum = 0;
            for (int i = 0; i < myEmpArrayList.size(); i++) {
                avgAgeSum += myEmpArrayList.get(i).age;

            }
            avgAgeMap.put(department, avgAgeSum / myEmpArrayList.size());
        }

        System.out.println(avgAgeMap);
        Employee2 seniorMostEmployee = null;
        int minYearOfJoining = Integer.MAX_VALUE;
        for (Employee2 emp : list) {
            if (minYearOfJoining > emp.yearOfJoining) {
                minYearOfJoining = emp.yearOfJoining;
                seniorMostEmployee = emp;
            }
        }
        System.out.println(seniorMostEmployee);

        Employee2 youngestEmployee = null;
        int minAge = Integer.MAX_VALUE;
        for (Employee2 emp : list) {
            if (minAge > emp.age) {
                minAge = emp.age;
                youngestEmployee = emp;
            }
        }
        System.out.println(youngestEmployee);

        Iterator<String> iterator = departmentMap.keySet().iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            int value = departmentMap.get(key).size();
            System.out.print(key + ":" + value+" ");
        }

        System.out.println("{female=" + countFemales + ",male=" + countMales + "}");

    }
}

0 replies

Gaurav-Joshi-31 · 2022-03-11T02:50:39Z

Gaurav-Joshi-31
Mar 11, 2022

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

class Employee {
    int id;
    static String country;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    Employee() {
        country = "India";
    }

    Employee(int id) {
        this();
        this.id = id;
    }

    Employee(String name) {
        this();
        this.name = name;
    }

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this(id);
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeDriver {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013,
                300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014,
                500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017,
                500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014,
                200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017,
                75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin",
                2016, 90000);
        Employee emp7 = new Employee();
        List<Employee> employeeList = Arrays.asList(emp1, emp2, emp3, emp4, emp5,
                emp6);

        Map<String, Double> averageSalary = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
        System.out.println(averageSalary);
        Optional<Employee> highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(highestPaid);

        Map<String, Double> averageAge = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
        System.out.println(averageAge);

        Optional<Employee> mostExperienced = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(mostExperienced);

        Optional<Employee> youngest = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getAge));
        System.out.println(youngest);
        Map<String, Long> count = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(count);

        Map<String, Long> genderCount = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
        System.out.println(genderCount);

    }
}

0 replies

Harshita-Joshi · 2022-03-11T03:09:41Z

Harshita-Joshi
Mar 11, 2022

package collections;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.stream.Collectors;

class Employee2
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee2(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}

public class EmpDriver {
    public static void main(String[] args) {
        
        Employee2 emp1 = new Employee2(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee2 emp2 = new Employee2(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee2 emp3 = new Employee2(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee2 emp4 = new Employee2(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee2 emp5 = new Employee2(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee2 emp6 = new Employee2(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        List<Employee2> employeeList = new ArrayList<>();
        employeeList.add(emp1);
        employeeList.add(emp2);
        employeeList.add(emp3);
        employeeList.add(emp4);
        employeeList.add(emp5);
        employeeList.add(emp6);


        // Average salary of male and female employees
        Map<String, Double> avgSalaryOfGenders = employeeList.stream().collect(Collectors.groupingBy(Employee2::getGender, Collectors.averagingDouble(Employee2::getSalary)));      
        System.out.println(avgSalaryOfGenders);

        // Details of the highest-paid employee in the organization from the given list of employees
        Optional<Employee2> highestPaidEmployeeOptional = employeeList.stream().collect(Collectors.maxBy(Comparator.comparingDouble(Employee2::getSalary)));
        Employee2 highestPaidEmployee = highestPaidEmployeeOptional.get();
        System.out.println(highestPaidEmployee);


        // Average age of each department
        Map<String, Double> avgAgeOfDepartments = employeeList.stream().collect(Collectors.groupingBy(Employee2::getDepartment, Collectors.averagingDouble(Employee2::getAge)));
        System.out.println(avgAgeOfDepartments);

        // the senior-most employee in the organization in terms of experience
        Optional<Employee2> seniorMostEmployeeOptional = employeeList.stream().sorted(Comparator.comparingInt(Employee2::getYearOfJoining)).findFirst();
        Employee2 seniorMostEmployee = seniorMostEmployeeOptional.get();
        System.out.println(seniorMostEmployee);

        // the youngest employee in the organization
        Optional<Employee2> youngestEmployeeOptional = employeeList.stream().min(Comparator.comparingInt(Employee2::getAge));
        Employee2 youngestEmployee = youngestEmployeeOptional.get();
        System.out.println(youngestEmployee);

        // Number of employees in each department
        Map<String, Long> employeeCountByDepartment = employeeList.stream().collect(Collectors.groupingBy(Employee2::getDepartment, HashMap::new, Collectors.counting()));
        System.out.println(employeeCountByDepartment);

        // Number of male and female employees in each department
        Map<String, Long> employeeCountByGender = employeeList.stream().collect(Collectors.groupingBy(Employee2::getGender, HashMap::new, Collectors.counting()));
        System.out.println(employeeCountByGender);
        
    }
}

0 replies

amruth2211 · 2022-03-11T03:26:14Z

amruth2211
Mar 11, 2022

package week6.StreamAPI;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStatistics {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(emp1);
        employeeList.add(emp2);
        employeeList.add(emp3);
        employeeList.add(emp4);
        employeeList.add(emp5);
        employeeList.add(emp6);

        // Count the number of employees in each department.
        HashMap<String, Integer> map = new HashMap<>();
        for (Employee emp : employeeList) {
            map.put(emp.department, map.getOrDefault(emp.department, 0) + 1);
        }

        // Find out the average salary of male and female employees.
        double msum = 0, fsum = 0;
        int mcount = 0, fcount = 0;
        for (Employee employee : employeeList) {
            if (employee.gender.equals("male")) {
                msum += employee.salary;
                mcount++;

            } else {
                fsum += employee.salary;
                fcount++;
            }
        }
        System.out.println("{feamle=" + fsum / fcount + ", male=" +
                msum / mcount + "}");

        // Get the details of the highest-paid employee in the organization from the
        // given list of employees.
        Optional<Employee> highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(highestPaid);

        // Get the average age of each department in an organization.
        Map<String, Double> agemap = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
        System.out.println(agemap);

        // Find out who is the senior-most employee in the organization in terms of
        // experience.
        Optional<Employee> experience = employeeList.stream().min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(experience);

        // Get the details of the youngest employee in the organization.
        Optional<Employee> minAge = employeeList.stream().min(Comparator.comparingInt(Employee::getAge));
        System.out.println(minAge);

        // Get the number of employees in each department if you have given a list of
        // employees.
        Map<String, Long> employeeByDept = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(employeeByDept);

        // Find out the number of male and female employees in the organization.
        Map<String, Long> employeeByGender = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
        System.out.println(employeeByGender);
    }
}

0 replies

Shubhi27 · 2022-03-11T03:29:42Z

Shubhi27
Mar 11, 2022

package collections;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Employee1 {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee1(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeList {
    public static void main(String[] args) {
        Employee1 emp1 = new Employee1(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee1 emp2 = new Employee1(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee1 emp3 = new Employee1(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee1 emp4 = new Employee1(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee1 emp5 = new Employee1(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee1 emp6 = new Employee1(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        List<Employee1> employeeList = new ArrayList<>();
        employeeList.add(emp1);
        employeeList.add(emp2);
        employeeList.add(emp3);
        employeeList.add(emp4);
        employeeList.add(emp5);
        employeeList.add(emp6);

        Map<String, Double> average = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getGender, Collectors.averagingDouble(Employee1::getSalary)));
        System.out.println(average);

        Employee1 highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee1::getSalary)).get();
        System.out.println("Optional" + highestPaid);

        Map<String, Double> avgAge = employeeList.stream()
                .collect(
                        Collectors.groupingBy(Employee1::getDepartment, Collectors.averagingDouble(Employee1::getAge)));
        System.out.println(avgAge);

        Employee1 seniorMost = employeeList.stream()
                .min(Comparator.comparingInt(Employee1::getYearOfJoining)).get();
        System.out.println("Optional" + seniorMost);

        Employee1 youngest = employeeList.stream()
                .min(Comparator.comparingInt(Employee1::getAge)).get();
        System.out.println("Optional" + youngest);

        Map<String, Long> total = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getDepartment, Collectors.counting()));
        System.out.println(total);

        Map<String, Long> maleFemaleCount = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getGender, Collectors.counting()));
        System.out.println(maleFemaleCount);

    }
}

0 replies

ratnadeepikavuddagiri · 2022-03-11T16:44:11Z

ratnadeepikavuddagiri
Mar 11, 2022

package JavaCollections.Maps;
import java.util.*;
import java.util.stream.Collectors;
class Employee
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}

public class EmployeeStatistics {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> employeeList = Arrays.asList(emp1, emp2, emp3, emp4,emp5, emp6);
        Map<String,Double>averageSalary =employeeList.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary)));
        System.out.println(averageSalary);
        Optional<Employee> highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(highestPaid);
        Map<String,Double> averageAge =employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge)));
        System.out.println(averageAge);
        Optional<Employee> seniorMost = employeeList.stream().min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(seniorMost);
        Optional<Employee> youngest = employeeList.stream().min(Comparator.comparingInt(Employee::getAge));
        System.out.println(youngest);        
        Map<String,Long> employeesInDept =employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
        System.out.println(employeesInDept);
        Map<String,Long> maleAndFemale =employeeList.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
        System.out.println(maleAndFemale);
    }
}

0 replies

rakeshGit419 · 2022-03-11T18:49:27Z

rakeshGit419
Mar 11, 2022

import java.util.*;
import java.util.stream.*;

class Employee {
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}

public class EmplyeStatistics{
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        
        List<Employee> empList = Arrays.asList(emp1,emp2,emp3,emp4,emp5,emp6);

        //1 count 
        Map<String,Integer> mapDeptCount = new HashMap<>();
        for(Employee e : empList)
            mapDeptCount.put(e.getDepartment(), mapDeptCount.getOrDefault(e.getDepartment(), 0)+1);
        System.out.println(mapDeptCount);


        //2 salary 
        int m = 0,f = 0;
        Map<String,Double> mapSalary = new HashMap<>();
        for(Employee e : empList){
            mapSalary.put(e.getGender(),mapSalary.getOrDefault(e.getGender(), 0.0)+e.getSalary());
            if(e.getGender().equals("male")) m++;
            else f++;
        }
        for(String i : mapSalary.keySet()){
            Double amt = mapSalary.get(i);
            if(i.equals("male"))mapSalary.put(i,amt/m);
            else mapSalary.put(i,amt/f);
        }
        System.out.println(mapSalary);
            
        //3 highest pay 
        DoubleSummaryStatistics empStats = empList.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(empStats.getMax());

        //4 avg age
        IntSummaryStatistics empAge = empList.stream().collect(Collectors.summarizingInt(Employee::getAge));
        System.out.println(empStats.getAverage());

        //5 & 6 -> senior-most & junior-most
        String senior = "";
        String junior = "";
        int mxExp = Integer.MIN_VALUE;
        int mnExp = Integer.MAX_VALUE;
        for(Employee i: empList){
            if(mxExp < (2022 - i.getYearOfJoining())){
                mxExp = 2022 - i.getYearOfJoining();
                senior = i.toString();
            }
            if(mnExp > (2022 - i.getYearOfJoining())){
                mnExp = 2022 - i.getYearOfJoining();
                junior = i.toString();
            }
        }
        System.out.println(senior);
        System.out.println(junior);

        //8  
        Map<String,Integer> mapGender = new HashMap<>();
        for(Employee e : empList)
            mapGender.put(e.getGender(), mapGender.getOrDefault(e.getGender(), 0)+1);
        System.out.println(mapGender);


    
    
    }
}

0 replies

Ashwesh09 · 2022-03-12T14:10:10Z

Ashwesh09
Mar 12, 2022

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

class Employee
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    
    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}
public class EmployeeStats {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> employees = Arrays.asList(emp1, emp2, emp3,emp4, emp5, emp6);
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary))));
        System.out.println(employees.stream().max((e1, e2) -> (int)(e1.getSalary() - e2.getSalary())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge))));
        System.out.println(employees.stream().max((e1, e2) -> (e1.getYearOfJoining() - e2.getYearOfJoining())));
        System.out.println(employees.stream().min((e1, e2) -> (e1.getAge() - e2.getAge())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting())));
    }
}

0 replies

sruthi-15-sketch · 2022-03-12T15:08:10Z

sruthi-15-sketch
Mar 12, 2022

import java.util.Arrays;
import java.util.HashMap;
import java.util.*;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStatistics {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        ArrayList<Employee> employeeList = new ArrayList<>(Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6));
        HashMap<String, Integer> h1 = new HashMap<>();
        HashMap<String, Float> age = new HashMap<>();
        HashMap<String, Integer> ethnicity = new HashMap<>();
        for (Employee e : employeeList) {
            if (h1.containsKey(e.department)) {
                h1.put(e.department, h1.get(e.department) + 1);
                int x = h1.get(e.department);
                age.put(e.department, (float) (age.get(e.department) + e.age));
            } else {
                h1.put(e.department, 1);
                age.put(e.department, (float) (e.age));
            }
            if (ethnicity.containsKey(e.gender)) {
                ethnicity.put(e.gender, ethnicity.get(e.gender) + 1);
            } else {
                ethnicity.put(e.gender, 1);
            }
        }
        System.out.println(h1);
        System.out.print("[");
        for (Map.Entry<String, Integer> m : h1.entrySet()) {
            System.out.print(m.getKey() + ":" + age.get(m.getKey()) / m.getValue());
            System.out.print(",");
        }
        System.out.println("]");
        double female_sum = 0;
        double male_sum = 0;
        int female_count = 0, male_count = 0;
        int highest_experienced = Integer.MAX_VALUE;
        Employee highestExperiencedEmployee = null;
        Employee highestPaidEmployee = null;
        double highestSalary = 0;
        int youngestEmployee = Integer.MAX_VALUE;
        Employee youngestEmployeeInOffice = null;
        for (Employee e : employeeList) {
            if (e.gender.equals("female")) {
                female_sum += e.salary;
                female_count += 1;
            } else {
                male_sum += e.salary;
                male_count += 1;
            }
            if (e.salary > highestSalary) {
                highestSalary = e.salary;
                highestPaidEmployee = e;
            }
            if (e.yearOfJoining < highest_experienced) {
                highest_experienced = e.yearOfJoining;
                highestExperiencedEmployee = e;
            }
            if (e.age < youngestEmployee) {
                youngestEmployee = e.age;
                youngestEmployeeInOffice = e;
            }
        }
        System.out.println("{female=" + (female_sum / female_count) + " male=" + (male_sum / male_count) + "]");
        System.out.println("Highest salary paid:[" + highestPaidEmployee + "]");
        System.out.println("Highest experienced employee:[" + highestExperiencedEmployee + "]");
        System.out.println("Youngest employee:[" + youngestEmployeeInOffice + "]");
        System.out.println(ethnicity);
    }
}

0 replies

PavanArvapally · 2022-03-12T16:30:36Z

PavanArvapally
Mar 12, 2022

package Tasks;

import java.util.*;
import java.util.stream.Collectors;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeesDriver {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        List<Employee> employeeList = Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6);

        Map<String, Double> averageSalary = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
        
        System.out.println(averageSalary);

        Optional<Employee> higestPaidEmployee = employeeList.stream().max((employee1, employee2) -> (int) (employee1.getSalary() - employee2.getSalary()));
        System.out.println(higestPaidEmployee);

        Map<String, Double> averageAge = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
        System.out.println(averageAge);

        Optional<Employee> experiencedEmployee = employeeList.stream().max((employee1, employee2) -> employee2.getYearOfJoining() - employee1.getYearOfJoining());
        System.out.println(experiencedEmployee);

        Optional<Employee> youngestEmployee = employeeList.stream().min((employee1, employee2) -> employee1.getAge()-employee2.getAge());
        System.out.println(youngestEmployee);

        Map<String, Long> noOfEmployeesByDept = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(noOfEmployeesByDept);

        Map<String, Long> noOfEmployeesByGender = employeeList.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
        System.out.println(noOfEmployeesByGender);
    }
}

0 replies

Sarfinaa · 2022-03-12T20:18:43Z

Sarfinaa
Mar 12, 2022

package week_5.streams;

import java.util.*;
import java.util.stream.Collectors;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStream {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> employeeList = Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6);
        // Count the number of employees in each department.
        Map<String, Long> map1 = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(map1);
        // Find out the average salary of male and female employees.
        Map<String, Double> avgSalary = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
        System.out.println(avgSalary);
        // Get the details of the highest-paid employee in the organization from the
        // given list of employees.
        Optional<Employee> highest = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(highest);
        // Get the average age of each department in an organization.
        Map<String, Double> avgAge = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,
                Collectors.averagingDouble(Employee::getAge)));
        System.out.println(avgAge);
        // Find out who is the senior-most employee in the organization in terms of
        // experience.
        Optional<Employee> mostExp = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(mostExp);
        // Get the details of the youngest employee in the organization.
        Optional<Employee> youngestEmp = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getAge));
        System.out.println(youngestEmp);
        // Find out the number of male and female employees in the organization.
        Map<String, Long> count = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
        System.out.println(count);
    }
}

0 replies

Krishreddy460 · 2022-03-13T07:01:08Z

Krishreddy460
Mar 13, 2022

package collections;
import java.util.*;
import java.util.stream.Collectors;

class Employee1
{
int id;
String name;
int age;
String gender;
String department;
int yearOfJoining;
double salary;

public Employee1(int id, String name, int age, String gender, String department, int yearOfJoining, double salary)
{
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.department = department;
this.yearOfJoining = yearOfJoining;
this.salary = salary;
}

public int getId()
{
return id;
}

public String getName()
{
return name;
}

public int getAge()
{
return age;
}

public String getGender()
{
return gender;
}

public String getDepartment()
{
return department;
}

public int getYearOfJoining()
{
return yearOfJoining;
}

public double getSalary()
{
return salary;
}

@OverRide
public String toString()
{
return "Id : "+id
+", Name : "+name
+", age : "+age
+", Gender : "+gender
+", Department : "+department
+", Year Of Joining : "+yearOfJoining
+", Salary : "+salary;
}
}

public class EmployeeStatitics
{
public static void main(String[] args)
{
Employee1 emp1 = new Employee1(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
Employee1 emp2 = new Employee1(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
Employee1 emp3 = new Employee1(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
Employee1 emp4 = new Employee1(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
Employee1 emp5 = new Employee1(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

List<Employee1> employeelist= new ArrayList<Employee1>();
employeelist.add(emp1);
employeelist.add(emp2);
employeelist.add(emp3);
employeelist.add(emp4);
employeelist.add(emp5);

// to print number of employees in each department
Map<String, Long> map1 = employeelist.stream().collect(Collectors.groupingBy(Employee1::getDepartment, Collectors.counting()));
System.out.println(map1);

// to print average salary

Map<String, Double> averageSalary = employeelist.stream()
.collect(Collectors.groupingBy(Employee1::getGender, Collectors.averagingDouble(Employee1::getSalary)));
System.out.println(averageSalary);

// most salary paid to
Optional high = employeelist.stream().max(Comparator.comparingDouble(Employee1::getSalary));
System.out.println(high);

// average age

Map<String, Double> age = employeelist.stream().collect(Collectors.groupingBy(Employee1::getDepartment, Collectors.averagingDouble(Employee1::getAge)));
System.out.println(age);

//Senior employee in organization

Employee1 seniorMost = employeelist.stream()
.min(Comparator.comparingInt(Employee1::getYearOfJoining)).get();
System.out.println("senior employee" + seniorMost);

// the youngest employee in the organization
Employee1 youngest = employeelist.stream().min(Comparator.comparingInt(Employee1::getAge)).get();
System.out.println("youngest employee::" + youngest);

//to get male and female count

Map<String, Long> genderCount = employeelist.stream().collect(Collectors.groupingBy(Employee1::getGender, Collectors.counting()));
System.out.println(genderCount);

}
}

0 replies

KaminiJha · 2022-03-13T13:09:29Z

KaminiJha
Mar 13, 2022

package Tasks;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStats {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> empList = Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6);
        // Count the number of employees in each department.
        empList.stream().collect(Collectors.groupingBy(Employee::getDepartment)).forEach((dep, list) -> {
            System.out.println(dep + " has " + list.size() + " employes");
        });
        // Find out the average salary of male and female employees.
        empList.stream().collect(Collectors.groupingBy(Employee::getGender)).forEach((gender, list) -> {
            OptionalDouble avg = list.stream().mapToDouble(emp -> emp.getSalary()).average();
            System.out.println(gender + " = " + avg.getAsDouble());
        });
        // Get the details of the highest-paid employee in the organization from the
        // given list of employees.
        List<Employee> sortedEmpList = empList.stream().sorted((e1, e2) -> (int) (e2.getSalary() - e1.getSalary()))
                .collect(Collectors.toList());
        System.out.println(sortedEmpList.get(0));
        // Get the average age of each department in an organization.
        empList.stream().collect(Collectors.groupingBy(Employee::getDepartment)).forEach((dept, list) -> {
            OptionalDouble avg = list.stream().mapToDouble(emp -> emp.getAge()).average();
            System.out.println(dept + " = " + avg.getAsDouble());
        });
        // Find out who is the senior-most employee in the organization in terms of
        // experience.
        Optional<Employee> mostExp = empList.stream()
                .min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(mostExp);
        // Get the details of the youngest employee in the organization.
        Optional<Employee> yougestEmp = empList.stream()
                .min(Comparator.comparingInt(Employee::getAge));
        System.out.println(yougestEmp);
        // Get the number of employees in each department if you have given a list of employees.
        Map<String,Long> eachDeptCount=empList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
        System.out.println(eachDeptCount);
        // Find out the number of male and female employees in the organization.
        empList.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting())).forEach((gender,count)->System.out.println("There are "+count+" "+ gender));

    }
}

0 replies

Prem-3 · 2022-03-13T17:43:39Z

Prem-3
Mar 13, 2022

import java.util.*;
import java.util.stream.*;
class Employee1
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee1(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}
public class EmployeeStatistics{
    public static void main(String[] args){
        Employee1 emp1 = new Employee1(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee1 emp2 = new Employee1(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee1 emp3 = new Employee1(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee1 emp4 = new Employee1(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee1 emp5 = new Employee1(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee1 emp6 = new Employee1(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee1> employeeList = Arrays.asList(emp1, emp2, emp3, emp4, emp5,emp6);
        Map<String,Integer> mapDeptCount = new HashMap<>();
        for(Employee1 e : employeeList)
            mapDeptCount.put(e.getDepartment(), mapDeptCount.getOrDefault(e.getDepartment(), 0)+1);
        System.out.println(mapDeptCount);


        //2 salary 
        int m = 0,f = 0;
        Map<String,Double> mapSalary = new HashMap<>();
        for(Employee1 e : employeeList){
            mapSalary.put(e.getGender(),mapSalary.getOrDefault(e.getGender(), 0.0)+e.getSalary());
            if(e.getGender().equals("male")) m++;
            else f++;
        }
        for(String i : mapSalary.keySet()){
            Double amt = mapSalary.get(i);
            if(i.equals("male"))mapSalary.put(i,amt/m);
            else mapSalary.put(i,amt/f);
        }
        System.out.println(mapSalary);
            
        //3 highest pay 
        DoubleSummaryStatistics empStats = employeeList.stream().collect(Collectors.summarizingDouble(Employee1::getSalary));
        System.out.println(empStats.getMax());

        //4 avg age
        IntSummaryStatistics empAge = employeeList.stream().collect(Collectors.summarizingInt(Employee1::getAge));
        System.out.println(empStats.getAverage());

        //5 & 6 -> senior-most & junior-most
        String senior = "";
        String junior = "";
        int mxExp = Integer.MIN_VALUE;
        int mnExp = Integer.MAX_VALUE;
        for(Employee1 i: employeeList){
            if(mxExp < (2022 - i.getYearOfJoining())){
                mxExp = 2022 - i.getYearOfJoining();
                senior = i.toString();
            }
            if(mnExp > (2022 - i.getYearOfJoining())){
                mnExp = 2022 - i.getYearOfJoining();
                junior = i.toString();
            }
        }
        System.out.println(senior);
        System.out.println(junior);

        //8  
        Map<String,Integer> mapGender = new HashMap<>();
        for(Employee1 e : employeeList)
            mapGender.put(e.getGender(), mapGender.getOrDefault(e.getGender(), 0)+1);
        System.out.println(mapGender);

    }
}

0 replies

Khyati-tripathi · 2022-03-13T18:44:41Z

Khyati-tripathi
Mar 13, 2022

package MapsModule;

import java.util.*;
import java.util.stream.*;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStatistics {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> employeeList = Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6);
        Map<String, Double> avgSalary = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
        System.out.println(avgSalary);
        Optional<Employee> highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(highestPaid);

        Map<String, Double> averageAge = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
        System.out.println(averageAge);

        Optional<Employee> senior = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getYearOfJoining));
        System.out.println(senior);

        Optional<Employee> youngest = employeeList.stream()
                .min(Comparator.comparingInt(Employee::getAge));
        System.out.println(youngest);
        Map<String, Long> totalEmp = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
        System.out.println(totalEmp);

        Map<String, Long> genCount = employeeList.stream()
                .collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
        System.out.println(genCount);

    }

}

0 replies

uzma23 · 2022-07-18T11:15:37Z

uzma23
Jul 18, 2022

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

class Employee57 {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee57(int id, String name, int age, String gender, String department, int yearOfJoining,
            double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class discussion57 {
    public static void main(String[] args) {
        Employee57 emp1 = new Employee57(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee57 emp2 = new Employee57(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee57 emp3 = new Employee57(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee57 emp4 = new Employee57(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee57 emp5 = new Employee57(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee57 emp6 = new Employee57(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        ArrayList<Employee57> list = new ArrayList<>();
        list.add(emp1);
        list.add(emp2);
        list.add(emp3);
        list.add(emp4);
        list.add(emp5);
        list.add(emp6);

        // TASK 1
        Map<String, Long> count = list.stream()

                .collect(Collectors.groupingBy(Employee57::getDepartment, Collectors.counting()));

        System.out.println(count);

        // TASK 2
        Map<String, Double> averageSalary = list.stream()
                .collect(Collectors.groupingBy(Employee57::getGender,
                        Collectors.averagingDouble(Employee57::getSalary)));
        System.out.println(averageSalary);

        // task3

        Optional<Employee57> highestPaid = list.stream().max(Comparator.comparingDouble(Employee57::getSalary));
        System.out.println(highestPaid);

        // task 4
        Map<String, Double> averageAge = list.stream()
                .collect(
                        Collectors.groupingBy(Employee57::getDepartment,
                                Collectors.averagingDouble(Employee57::getAge)));
        System.out.println(averageAge);

        // task 5

        Optional<Employee57> mostExperienced = list.stream()
                .min(Comparator.comparingInt(Employee57::getYearOfJoining));
        System.out.println(mostExperienced);

        // task 6
        Optional<Employee57> youngest = list.stream()
                .min(Comparator.comparingInt(Employee57::getAge));
        System.out.println(youngest);

        // task 7

        Map<String, Long> countt = list.stream()
                .collect(Collectors.groupingBy(Employee57::getDepartment, Collectors.counting()));

        System.out.println("No. of employees in each department :" + countt);

        // task 8

        Map<String, Long> genderCount = list.stream()
                .collect(Collectors.groupingBy(Employee57::getGender, Collectors.counting()));
        System.out.println("No. of male and female employees in each department : " + genderCount);

    }

}

0 replies

ghost · 2022-07-18T11:20:17Z

ghost
Jul 18, 2022

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

class Employee {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class d57 {
    public static void main(String[] args) {
        Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
        List<Employee> employees = Arrays.asList(emp1, emp2, emp3, emp4, emp5, emp6);
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary))));
        System.out.println(employees.stream().max((e1, e2) -> (int) (e1.getSalary() - e2.getSalary())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge))));
        System.out.println(employees.stream().max((e1, e2) -> (e1.getYearOfJoining() - e2.getYearOfJoining())));
        System.out.println(employees.stream().min((e1, e2) -> (e1.getAge() - e2.getAge())));
        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.counting())));
    }
}

0 replies

Kuntapaliwal · 2022-07-19T04:25:23Z

Kuntapaliwal
Jul 19, 2022

package java_programs;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

class EmployeeData1 {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public EmployeeData1(int id, String name, int age, String gender, String department, int yearOfJoining,
            double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

public class EmployeeStatics {

    public static void main(String[] args) {

        EmployeeData1 emp1 = new EmployeeData1(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        EmployeeData1 emp2 = new EmployeeData1(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        EmployeeData1 emp3 = new EmployeeData1(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        EmployeeData1 emp4 = new EmployeeData1(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        EmployeeData1 emp5 = new EmployeeData1(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        EmployeeData1 emp6 = new EmployeeData1(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        List<EmployeeData1> employees = new ArrayList<EmployeeData1>();
        employees.add(emp1);
        employees.add(emp2);
        employees.add(emp3);
        employees.add(emp4);
        employees.add(emp5);
        employees.add(emp6);

        Map<String, Long> count = employees.stream()
                .collect(Collectors.groupingBy(EmployeeData1::getDepartment, Collectors.counting()));

        System.out.println(count);

        // employees.stream().collect(Collectors.groupingBy(e -> e.getGender(),
        // Collectors.averagingDouble(e -> e.getSalary())));////why this is not working  as lamda expression ended so again we have to start lamda if want to use otherwise we can use function referencing
        // as lamda expression ends there only again we required a

        Map<String, Double> data = employees.stream().collect(
                Collectors.groupingBy(e -> e.getGender(), Collectors.averagingDouble(EmployeeData1::getSalary)));

        System.out.println(data);

        // Get the details of the highest-paid employee in the organization from the
        // given list of employees.

        Comparator<EmployeeData1> comparedBySalary = (obj1, obj2) -> (int) obj1.getSalary() - (int) obj2.getSalary();
        Collections.sort(employees, comparedBySalary);
        System.out.println(employees.get(0));

        employees.stream().sorted(comparedBySalary).limit(1).forEach(emp -> System.out.println(emp));

        // Get the average age of each department in an organization.
        Map<String, Double> averageAge = employees.stream()
                .collect(Collectors.groupingBy(e -> e.getDepartment(), Collectors.averagingInt(EmployeeData1::getAge)));
        System.out.println(averageAge);

        // Find out who is the senior-most employee in the organization in terms of
        // experience.
        Optional<EmployeeData1> mostExperiencedEmployee = employees.stream()
                .min(Comparator.comparingInt(EmployeeData1::getAge));
        System.out.println(mostExperiencedEmployee);

        // Get the details of the youngest employee in the organization.
        Optional<EmployeeData1> minorExperiencedEmployee = employees.stream()
                .max(Comparator.comparingInt(EmployeeData1::getAge));
        System.out.println(minorExperiencedEmployee);

        // Get the number of employees in each department if you have given a list of
        // employees.
        HashMap<String, Integer> personByDepartment = new HashMap<>();

        for (EmployeeData1 e : employees) {
            if (personByDepartment.containsKey(e.getDepartment()))
                personByDepartment.put(e.getDepartment(), personByDepartment.get(e.getDepartment()) + 1);
            else
                personByDepartment.put(e.getDepartment(), 1);
        }

        // int value1 = personByDepartment.get("Admin");
        // for (Map.Entry entry : personByDepartment.entrySet()) {
        // System.out.println(entry.getKey() + " " + entry.getValue());
        // }

        personByDepartment.forEach((key, value) -> System.out.println(key + " " + value));

        // Find out the number of male and female employees in the organization.

        Map<String, Long> genderCount = employees.stream()
                .collect(Collectors.groupingBy(e -> e.getGender(), Collectors.counting()));
        System.out.println(genderCount);

    }

}

0 replies

Coder-093 · 2022-07-19T05:57:00Z

Coder-093
Jul 19, 2022

import java.util.*;
import java.util.stream.Collectors;

public class task57 {
  public static void main(String[] args) {
    Employeee emp1 = new Employeee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
    Employeee emp2 = new Employeee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
    Employeee emp3 = new Employeee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
    Employeee emp4 = new Employeee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
    Employeee emp5 = new Employeee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
    Employeee emp6 = new Employeee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

    ArrayList<Employeee> emplist = new ArrayList<Employeee>();
    emplist.add(emp1);
    emplist.add(emp2);
    emplist.add(emp3);
    emplist.add(emp4);
    emplist.add(emp5);
    emplist.add(emp6);

    System.out.println("Count the number of employees in each department");
    System.out
        .println(emplist.stream().collect(Collectors.groupingBy(Employeee::getDepartment, Collectors.counting())));
    System.out.println();

    System.out.println("Find out the average salary of male and female employees.");
    System.out.println(emplist.stream()
        .collect(Collectors.groupingBy(Employeee::getGender, Collectors.averagingDouble(Employeee::getSalary))));
    System.out.println();

    System.out
        .println("Get the details of the highest-paid employee in the organization from the given list of employees.");
    System.out.println(emplist.stream().max(Comparator.comparingDouble(Employeee::getSalary)));
    System.out.println();

    System.out.println("Get the average age of each department in an organization.");
    System.out.println(emplist.stream()
        .collect(Collectors.groupingBy(Employeee::getDepartment, Collectors.averagingDouble(Employeee::getAge))));
    System.out.println();

    System.out.println("Find out who is the senior-most employee in the organization in terms of experience.");
    System.out.println(emplist.stream().max(Comparator.comparing(Employeee::getAge)));
    System.out.println();

    System.out.println("Get the details of the youngest employee in the organization.");
    System.out.println(emplist.stream().min(Comparator.comparing(Employeee::getAge)));
    System.out.println();

    System.out.println("Find out the number of male and female employees in the organization.");
    System.out.println(emplist.stream().collect(Collectors.groupingBy(Employeee::getGender, Collectors.counting())));
  }
}

class Employeee {
  int id;
  String name;
  int age;
  String gender;
  String department;
  int yearOfJoining;
  double salary;

  public Employeee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.department = department;
    this.yearOfJoining = yearOfJoining;
    this.salary = salary;
  }

  public int getId() {
    return id;
  }

  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }

  public String getGender() {
    return gender;
  }

  public String getDepartment() {
    return department;
  }

  public int getYearOfJoining() {
    return yearOfJoining;
  }

  public double getSalary() {
    return salary;
  }

  @Override
  public String toString() {
    return "Id : " + id
        + ", Name : " + name
        + ", age : " + age
        + ", Gender : " + gender
        + ", Department : " + department
        + ", Year Of Joining : " + yearOfJoining
        + ", Salary : " + salary;
  }
}

0 replies

meghvi-raj · 2022-07-19T06:38:31Z

meghvi-raj
Jul 19, 2022

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;

import java.util.Iterator;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class D57 {

    public static void main(String[] args) {
        Employee1 emp1 = new Employee1(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
        Employee1 emp2 = new Employee1(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
        Employee1 emp3 = new Employee1(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
        Employee1 emp4 = new Employee1(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
        Employee1 emp5 = new Employee1(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
        Employee1 emp6 = new Employee1(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

        ArrayList<Employee1> employeeList = new ArrayList<>();
        employeeList.add(emp1);
        employeeList.add(emp2);
        employeeList.add(emp3);
        employeeList.add(emp4);
        employeeList.add(emp5);
        employeeList.add(emp6);

        // task1
        Map<String, Long> count = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getDepartment, Collectors.counting()));
        System.out.println("No of employees in each department " + count);

        // task2
        Map<String, Double> averageSalary = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getGender, Collectors.averagingDouble(Employee1::getSalary)));
        System.out.println("Average salary of male and female employees : " + averageSalary);

        // task3
        Optional<Employee1> highestPaid = employeeList.stream().max(Comparator.comparingDouble(Employee1::getSalary));
        System.out.println("Details of highest paid employee : " + highestPaid);

        // task 4
        Map<String, Double> averageAge = employeeList.stream()
                .collect(
                        Collectors.groupingBy(Employee1::getDepartment, Collectors.averagingDouble(Employee1::getAge)));
        System.out.println("Average age in each department : " + averageAge);

        // task 5
        Optional<Employee1> mostExperienced = employeeList.stream()
                .min(Comparator.comparingInt(Employee1::getYearOfJoining));
        System.out.println("Senior most employee in terms of experience : " + mostExperienced);

        // task 6
        Optional<Employee1> youngest = employeeList.stream()
                .min(Comparator.comparingInt(Employee1::getAge));
        System.out.println("Youngest employee in the organisation : " + youngest);

        // task 7
        Map<String, Long> countt = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getDepartment, Collectors.counting()));
        System.out.println("No. of employees in each department :" + countt);

        // task 8
        Map<String, Long> genderCount = employeeList.stream()
                .collect(Collectors.groupingBy(Employee1::getGender, Collectors.counting()));
        System.out.println("No. of male and female employees in each department : " + genderCount);

    }

}

class Employee1 {
    int id;
    String name;
    int age;
    String gender;
    String department;
    int yearOfJoining;
    double salary;

    public Employee1(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }

    public String getDepartment() {
        return department;
    }

    public int getYearOfJoining() {
        return yearOfJoining;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public String toString() {
        return "Id : " + id
                + ", Name : " + name
                + ", age : " + age
                + ", Gender : " + gender
                + ", Department : " + department
                + ", Year Of Joining : " + yearOfJoining
                + ", Salary : " + salary;
    }
}

0 replies

lingamurthi · 2022-08-22T10:04:41Z

lingamurthi
Aug 22, 2022

package com.lingu;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class Employee {

	
	
	    int id;
	    String name; 
	    int age;
	    String gender; 
	    String department;  
	    int yearOfJoining;
	    double salary;
	      
	    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
	    {
	        this.id = id;
	        this.name = name;
	        this.age = age;
	        this.gender = gender;
	        this.department = department;
	        this.yearOfJoining = yearOfJoining;
	        this.salary = salary;
	    }
	      
	    public int getId() 
	    {
	        return id;
	    }
	      
	    public String getName() 
	    {
	        return name;
	    }
	      
	    public int getAge() 
	    {
	        return age;
	    }
	      
	    public String getGender() 
	    {
	        return gender;
	    }
	      
	    public String getDepartment() 
	    {
	        return department;
	    }
	      
	    public int getYearOfJoining() 
	    {
	        return yearOfJoining;
	    }
	      
	    public double getSalary() 
	    {
	        return salary;
	    }
	      
	    @Override
	    public String toString() 
	    {
	        return "Id : "+id
	                +", Name : "+name
	                +", age : "+age
	                +", Gender : "+gender
	                +", Department : "+department
	                +", Year Of Joining : "+yearOfJoining
	                +", Salary : "+salary;
	    }
	
	public static void main(String[] args) {
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
		
		ArrayList<Employee> employeeList= new ArrayList();
		employeeList.add(emp1);
		employeeList.add(emp2);
		employeeList.add(emp3);
		employeeList.add(emp4);
		employeeList.add(emp5);
		employeeList.add(emp6);
		
		Map<String, Long> employeeCountByDepartment = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
       System.out.println(employeeCountByDepartment);
       
       Map<String, Double> avgSalaryOfMaleAndFemaleEmployees = employeeList.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary)));
       System.out.println(avgSalaryOfMaleAndFemaleEmployees);
       
       Optional<Employee>  detailsofhighestpaidemployee  = employeeList.stream().collect(Collectors.maxBy(Comparator.comparingDouble(Employee::getSalary)));
       System.out.println(detailsofhighestpaidemployee);
       
       Map<String, Double> averageageofeachdepartment  = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge)));
       System.out.println(averageageofeachdepartment);
       
       Optional<Employee> seniorMostEmployeeWrapper = employeeList.stream().sorted(Comparator.comparingInt(Employee::getYearOfJoining)).findFirst();
       System.out.println(seniorMostEmployeeWrapper);
       
       Optional<Employee>  youngestemployeeintheorganization = employeeList.stream().min(Comparator.comparingInt(Employee::getAge));
       System.out.println(youngestemployeeintheorganization);
       
       Map<String, Long> numberofemployeesineachdepartment = employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
       System.out.println(numberofemployeesineachdepartment);
       
       Map<String, Long> numberofmaleandfemaleemployees = employeeList.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
       System.out.println(numberofmaleandfemaleemployees);
	}

}

0 replies

NavneetBais · 2022-08-22T10:22:30Z

NavneetBais
Aug 22, 2022

import java.util.*;
import java.util.stream.Collectors;
public class Driver {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
		List<Employee> employees = new ArrayList<>();
			employees.add(emp1);
			employees.add(emp2);
			employees.add(emp3);
			employees.add(emp4);
			employees.add(emp5);
			employees.add(emp6);
			
		//Calculating no. of emp in department 
			List<Employee> x =  employees.stream().filter( o -> o.department.equals("HR")).toList();
			List<Employee> y =  employees.stream().filter( o -> o.department.equals("Account")).toList();
			List<Employee> z =  employees.stream().filter( o -> o.department.equals("Admin")).toList();

			OptionalDouble avgMen = employees.stream().filter(o -> o.gender.equalsIgnoreCase("male")).mapToDouble(Employee::getSalary).average();
			OptionalDouble avgFemale = employees.stream().filter(o -> o.gender.equalsIgnoreCase("female")).mapToDouble(Employee::getSalary).average();
			System.out.println("{female=" + avgFemale.getAsDouble() +", male=" + avgMen.getAsDouble() + "}");

			
			OptionalDouble highest = employees.stream().mapToDouble(Employee::getSalary).max();
			OptionalDouble mostExp = employees.stream().mapToDouble(Employee::getYearOfJoining).min();
			OptionalDouble minExp = employees.stream().mapToDouble(Employee::getYearOfJoining).max();
			
			for(Employee e : employees) {
				if(e.getSalary() == highest.getAsDouble()) {
					System.out.println(e);
					break;
				}
			}
			OptionalDouble avgAccount = employees.stream().filter(o -> o.department.equalsIgnoreCase("Account")).mapToDouble(Employee::getAge).average();
			OptionalDouble avgAdmin = employees.stream().filter(o -> o.department.equalsIgnoreCase("Admin")).mapToDouble(Employee::getAge).average();
			OptionalDouble avgAHr = employees.stream().filter(o -> o.department.equalsIgnoreCase("HR")).mapToDouble(Employee::getAge).average();
			System.out.println("{ Account=" +avgAccount.getAsDouble() + ", HR=" + avgAHr.getAsDouble() + ", Admin=" + avgAdmin.getAsDouble() + "}");
			
			for(Employee e : employees) {
				if(e.getYearOfJoining() == minExp.getAsDouble()) {
					System.out.println(e);
					break;
				}
			}
			
			for(Employee e : employees) {
				if(e.getYearOfJoining() == mostExp.getAsDouble()) {
					System.out.println(e);
					break;
				}
			}
			System.out.println("{Account=" + y.size() +", HR=" + x.size() + ", Admin=" + z.size() + "}");
			 Map<String, Long> genderCount = employees.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
		        System.out.println( genderCount);
			
			
	}

}

0 replies

ShravanKV2310 · 2022-08-22T10:25:30Z

ShravanKV2310
Aug 22, 2022

Code

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
	public static void main(String[] args) {
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
		List<Employee> employee = new ArrayList<Employee>();
		employee.add(emp1);
		employee.add(emp2);
		employee.add(emp3);
		employee.add(emp4);
		employee.add(emp5);
		employee.add(emp6);
		Map<String, Long> collect = employee.stream().collect(Collectors.groupingBy(e -> e.getDepartment(),Collectors.counting()));
		System.out.println(collect);
		employee.stream().count();
		Map<String, Double> collect2 = employee.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary)));
		System.out.println(collect2);
		Optional<Employee> findFirst = employee.stream().sorted(Comparator.comparingDouble(Employee::getSalary).reversed()).findFirst();
		System.out.println(findFirst);
		Map<String, Double> collect3 = employee.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingInt(Employee::getAge)));
		System.out.println(collect3);
		Optional<Employee> findFirst2 = employee.stream().sorted(Comparator.comparingInt(Employee::getYearOfJoining)).findFirst();
		System.out.println(findFirst2);
		Optional<Employee> findFirst3 = employee.stream().sorted(Comparator.comparingInt(Employee::getAge)).findFirst();
		System.out.println(findFirst3);
		Map<String, Long> collect4 = employee.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
		System.out.println(collect4);
	}
}
class Employee
{
    int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
      
    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
    {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.department = department;
        this.yearOfJoining = yearOfJoining;
        this.salary = salary;
    }
      
    public int getId() 
    {
        return id;
    }
      
    public String getName() 
    {
        return name;
    }
      
    public int getAge() 
    {
        return age;
    }
      
    public String getGender() 
    {
        return gender;
    }
      
    public String getDepartment() 
    {
        return department;
    }
      
    public int getYearOfJoining() 
    {
        return yearOfJoining;
    }
      
    public double getSalary() 
    {
        return salary;
    }
      
    @Override
    public String toString() 
    {
        return "Id : "+id
                +", Name : "+name
                +", age : "+age
                +", Gender : "+gender
                +", Department : "+department
                +", Year Of Joining : "+yearOfJoining
                +", Salary : "+salary;
    }
}

0 replies

Abhishekk6 · 2022-08-22T10:26:02Z

Abhishekk6
Aug 22, 2022

package p1;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.stream.Collectors;

class Employee{
	int id;
    String name; 
    int age;
    String gender; 
    String department;  
    int yearOfJoining;
    double salary;
    
    
	public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.department = department;
		this.yearOfJoining = yearOfJoining;
		this.salary = salary;
	}


	public int getId() {
		return id;
	}


	public void setId(int id) {
		this.id = id;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	public String getGender() {
		return gender;
	}


	public void setGender(String gender) {
		this.gender = gender;
	}


	public String getDepartment() {
		return department;
	}


	public void setDepartment(String department) {
		this.department = department;
	}


	public int getYearOfJoining() {
		return yearOfJoining;
	}


	public void setYearOfJoining(int yearOfJoining) {
		this.yearOfJoining = yearOfJoining;
	}


	public double getSalary() {
		return salary;
	}


	public void setSalary(double salary) {
		this.salary = salary;
	}


	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", department="
				+ department + ", yearOfJoining=" + yearOfJoining + ", salary=" + salary + "]";
	}   
}
public class problem57 {
	public static void main(String[] args) {
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
	
		ArrayList<Employee> list = new ArrayList<>();
        list.add(emp1);
        list.add(emp2);
        list.add(emp3);
        list.add(emp4);
        list.add(emp5);
        list.add(emp6);
        
        Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
       System.out.println(collect);
       System.out.println();
       Map<String, Double> collect2 = list.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary)));
       System.out.println(collect2);
       System.out.println();
       Double double1 = list.stream().map(x->x.getSalary()).sorted(Comparator.reverseOrder()).findFirst().get();
	    System.out.println(double1);
	    System.out.println();
	    Map<String, Double> collect3 = list.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge)));
	System.out.println(collect3);
	System.out.println();
	Optional<Employee> findFirst = list.stream().sorted(Comparator.comparingInt(Employee::getYearOfJoining)).findFirst();
	System.out.println(findFirst);
	System.out.println();
	Optional<Employee> findFirst2 = list.stream().sorted(Comparator.comparing(Employee::getAge)).findFirst();
	System.out.println(findFirst2);
	System.out.println();
	Map<String, Long> collect4 = list.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
	System.out.println(collect4);
	}

}

0 replies

AjayBagul · 2022-08-22T10:42:09Z

AjayBagul
Aug 22, 2022

code

package assignment57;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class EmployeeList {
	
	public static void main(String[] args) {
		
	
	List<Employee> employeeList = new ArrayList<>();
	
	Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
	Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
	Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
	Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
	Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
	Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
	
	employeeList.add(emp1);
	employeeList.add(emp2);
	employeeList.add(emp3);
	employeeList.add(emp4);
	employeeList.add(emp5);
	employeeList.add(emp6);
	
	List<Employee> list = Arrays.asList(emp1,emp2,emp3,emp4,emp5,emp6 );
	
	//Counting on department wise
	Map<String , Long> list8 = list.stream().collect(Collectors.groupingBy(Employee:: getDepartment , Collectors.counting()));
	System.out.println(list8);
	//Avarage
	Map<String, Double> map = list.stream().collect(Collectors.groupingBy(Employee:: getGender, Collectors.averagingDouble(Employee:: getSalary)));
	System.out.println("Avarge:" +map);
	
	//Highest payment
	Optional<Employee> list1 = list.stream().max(Comparator.comparing(Employee::getSalary));
	System.out.println("Highest Salry" +list1);
	
	//Avarage age
	Map<String, Double> list3 = list.stream().collect(Collectors.groupingBy(Employee::getDepartment , Collectors.averagingDouble(Employee:: getAge)));	
	System.out.println(list3);

	//Senior Employee
	Optional<Employee> list4 = list.stream().min(Comparator.comparing(Employee:: getYearOfJoining));
	System.out.println(list4);
	
	//Youngest Employee
	Optional<Employee> list5 = list.stream().min(Comparator.comparing(Employee:: getAge));
	System.out.println("Youngest Employee" +list5);
	
	//Get counting of each department
	Map<String, Long> list6 = list.stream().collect(Collectors.groupingBy(Employee:: getDepartment , Collectors.counting()));
	System.out.println(list6);
	
	// Number of male and female employee
	Map<String , Long> list7 = list.stream().collect(Collectors.groupingBy(Employee:: getGender , Collectors.counting()));
	System.out.println(list7);
	}
	}

0 replies

harsh1997agg · 2022-08-22T11:19:47Z

harsh1997agg
Aug 22, 2022

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.stream.Collectors;
import java.util.*;
class Employee
{
int id;
String name;
int age;
String gender;
String department;
int yearOfJoining;
double salary;

public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
{
    this.id = id;
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.department = department;
    this.yearOfJoining = yearOfJoining;
    this.salary = salary;
}
  
public int getId() 
{
    return id;
}
  
public String getName() 
{
    return name;
}
  
public int getAge() 
{
    return age;
}
  
public String getGender() 
{
    return gender;
}
  
public String getDepartment() 
{
    return department;
}
  
public int getYearOfJoining() 
{
    return yearOfJoining;
}
  
public double getSalary() 
{
    return salary;
}
  
@Override
public String toString() 
{
    return "Id : "+id
            +", Name : "+name
            +", age : "+age
            +", Gender : "+gender
            +", Department : "+department
            +", Year Of Joining : "+yearOfJoining
            +", Salary : "+salary;
}










public static void main(String[] args) {

Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

List<Employee> e=new LinkedList<>(Arrays.asList(emp1,emp2,emp3,emp4,emp5,emp6));
//Count the number of employees in each department.

long count= e.stream().map(i -> i.getId()).count();
System.out.println("count"+count);
//Find out the average salary of male and female employees.
OptionalDouble maleAVGSalary=e.stream().filter(i -> i.getGender()=="male").mapToDouble(i->i.getSalary()).average();
System.out.println("maleAVGSalary" +maleAVGSalary);
OptionalDouble femaleAVGSalary=e.stream().filter(i -> i.getGender()=="female").mapToDouble(i->i.getSalary()).average();
System.out.println("femaleAVGSalary"+femaleAVGSalary);

Map<String, Double> avgSalaryOfGenders = e.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
System.out.println("AverageSalary"+avgSalaryOfGenders);

//Get the details of the highest-paid employee in the organization from the given list of employees.
Optional mostExperienced=e.stream().max(Comparator.comparing(Employee::getSalary));
System.out.println("Employee With Maximum Salary"+mostExperienced);

//Get the average age of each department in an organization

Map<String,Double> avg_age_dept=e.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge)));
System.out.println("avg_age_dept"+avg_age_dept);

//Find out who is the senior-most employee in the organization in terms of experience.
Optional q=e.stream().max(Comparator.comparing(Employee::getAge));
System.out.println(q);

Optional qa=e.stream().max(Comparator.comparing(Employee::getAge));
System.out.println("Person with Maximum Experience:-"+qa.get().name);

//Get the details of the youngest employee in the organization.
Optional qao=e.stream().min(Comparator.comparing(Employee::getAge));
System.out.println("Youngest:- "+qao.get().name);
//Get the number of employees in each department if you have given a list of employees.

Map<String,Long> ma=e.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
System.out.println(ma);

//Find out the number of male and female employees in the organization.
Map<String,Long> count_by_gender=e.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
System.out.println("Number of male"+count_by_gender.get("male"));

Map<String,Long> count_by_gender1=e.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
System.out.println(count_by_gender1);
}

}``

0 replies

Sk216995 · 2022-08-22T11:33:04Z

Sk216995
Aug 22, 2022

import java.util.*;
import java.util.stream.Collectors;

public class Employee{
int id;
static String country;
String name;
int age;
String gender;
String department;
int yearOfJoining;
double salary;

public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
	super();
	this.id = id;
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.department = department;
	this.yearOfJoining = yearOfJoining;
	this.salary = salary;
}







public int getId() {
	return id;
}







public void setId(int id) {
	this.id = id;
}







public static String getCountry() {
	return country;
}







public static void setCountry(String country) {
	Employee2.country = country;
}







public String getName() {
	return name;
}







public void setName(String name) {
	this.name = name;
}







public int getAge() {
	return age;
}







public void setAge(int age) {
	this.age = age;
}







public String getGender() {
	return gender;
}







public void setGender(String gender) {
	this.gender = gender;
}







public String getDepartment() {
	return department;
}







public void setDepartment(String department) {
	this.department = department;
}







public int getYearOfJoining() {
	return yearOfJoining;
}







public void setYearOfJoining(int yearOfJoining) {
	this.yearOfJoining = yearOfJoining;
}







public double getSalary() {
	return salary;
}







public void setSalary(double salary) {
	this.salary = salary;
}







@Override
public String toString() {
	return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", department="
			+ department + ", yearOfJoining=" + yearOfJoining + ", salary=" + salary + "]";
}







public static void main(String[] args) {
	Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
	Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
	Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
	Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
	Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
	Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
	
	
	List<Employee> al=new ArrayList<Employee>();
	al.add(emp1);
	al.add(emp2);
	al.add(emp3);
	al.add(emp4);
	al.add(emp5);
	al.add(emp6);
	
	//Count the number of employees in each department.
	
	long as= al.stream().count();
	System.out.println("the count of the employee");
	System.out.println(as);
	
	//Find out the average salary of male and female employees.
	
OptionalDouble d=	al.stream().filter(p->p.getGender()=="male").mapToDouble(p->p.getSalary()).average();
System.out.println("average salary of men");
	System.out.println(d);
	System.out.println("avarage salary of women");
	OptionalDouble d1=	al.stream().filter(p->p.getGender()=="female").mapToDouble(p->p.getSalary()).average();
	System.out.println(d1);
	
	
	//Get the details of the highest-paid employee in the organization from the given list of employees.
	
	
	


List<Employee> op=al.stream().sorted(Comparator.comparing(Employee::getSalary)).limit(3).collect(Collectors.toList());
System.out.println("Get the details of the highest-paid employee in the organization");
	System.out.println(op);
	
	
	//Get the average age of each department in an organization.
	
	OptionalDouble asa=al.stream().mapToDouble(p->p.getAge()).average();
	System.out.println("Get the average age of each department in an organization.");
	System.out.println(asa);
	
	
	
	//Find out who is the senior-most employee in the organization in terms of experience.
	Optional<Employee> asa2=al.stream().max(Comparator.comparing(Employee::getAge));
	System.out.println("Find out who is the senior-most employee in the organization in terms of experience.");
	System.out.println(asa2.get().name);
	
	//Get the details of the youngest employee in the `organization.`
	Optional<Employee> asa3=al.stream().min(Comparator.comparing(Employee::getAge));
	System.out.println("Get the details of the youngest employee in the organization.");
	System.out.println(asa3.get().name);
	
	
	//Find out the number of male and female employees in the organization
         Map<String,Long> r=al.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
         System.out.println(r);
}

}

0 replies

Gauravkumar930 · 2022-08-23T05:46:50Z

Gauravkumar930
Aug 23, 2022

package p1;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.stream.Collectors;

class Employee{
int id;
String name;
int age;
String gender;
String department;
int yearOfJoining;
double salary;

public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) {
	super();
	this.id = id;
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.department = department;
	this.yearOfJoining = yearOfJoining;
	this.salary = salary;
}


public int getId() {
	return id;
}


public void setId(int id) {
	this.id = id;
}


public String getName() {
	return name;
}


public void setName(String name) {
	this.name = name;
}


public int getAge() {
	return age;
}


public void setAge(int age) {
	this.age = age;
}


public String getGender() {
	return gender;
}


public void setGender(String gender) {
	this.gender = gender;
}


public String getDepartment() {
	return department;
}


public void setDepartment(String department) {
	this.department = department;
}


public int getYearOfJoining() {
	return yearOfJoining;
}


public void setYearOfJoining(int yearOfJoining) {
	this.yearOfJoining = yearOfJoining;
}


public double getSalary() {
	return salary;
}


public void setSalary(double salary) {
	this.salary = salary;
}


@Override
public String toString() {
	return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", department="
			+ department + ", yearOfJoining=" + yearOfJoining + ", salary=" + salary + "]";
}

}
public class problem57 {
public static void main(String[] args) {
Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);

	ArrayList<Employee> list = new ArrayList<>();
    list.add(emp1);
    list.add(emp2);
    list.add(emp3);
    list.add(emp4);
    list.add(emp5);
    list.add(emp6);
    
    Map<String, Long> collect = list.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));
   System.out.println(collect);
   System.out.println();
   Map<String, Double> collect2 = list.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.averagingDouble(Employee::getSalary)));
   System.out.println(collect2);
   System.out.println();
   Double double1 = list.stream().map(x->x.getSalary()).sorted(Comparator.reverseOrder()).findFirst().get();
    System.out.println(double1);
    System.out.println();
    Map<String, Double> collect3 = list.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.averagingDouble(Employee::getAge)));
System.out.println(collect3);
System.out.println();
Optional<Employee> findFirst = list.stream().sorted(Comparator.comparingInt(Employee::getYearOfJoining)).findFirst();
System.out.println(findFirst);
System.out.println();
Optional<Employee> findFirst2 = list.stream().sorted(Comparator.comparing(Employee::getAge)).findFirst();
System.out.println(findFirst2);
System.out.println();
Map<String, Long> collect4 = list.stream().collect(Collectors.groupingBy(Employee::getGender,Collectors.counting()));
System.out.println(collect4);
}

}

0 replies

Gauravkumar930 · 2022-08-27T06:05:04Z

Gauravkumar930
Aug 27, 2022

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

class Employee{
	 int id;
	    String name; 
	    int age;
	    String gender; 
	    String department;  
	    int yearOfJoining;
	    double salary;
	      
	    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
	    {
	        this.id = id;
	        this.name = name;
	        this.age = age;
	        this.gender = gender;
	        this.department = department;
	        this.yearOfJoining = yearOfJoining;
	        this.salary = salary;
	    }
	      
	    public int getId() 
	    {
	        return id;
	    }
	      
	    public String getName() 
	    {
	        return name;
	    }
	      
	    public int getAge() 
	    {
	        return age;
	    }
	      
	    public String getGender() 
	    {
	        return gender;
	    }
	      
	    public String getDepartment() 
	    {
	        return department;
	    }
	      
	    public int getYearOfJoining() 
	    {
	        return yearOfJoining;
	    }
	      
	    public double getSalary() 
	    {
	        return salary;
	    }
	      
	    @Override
	    public String toString() 
	    {
	        return "Id : "+id
	                +", Name : "+name
	                +", age : "+age
	                +", Gender : "+gender
	                +", Department : "+department
	                +", Year Of Joining : "+yearOfJoining
	                +", Salary : "+salary;
	    }
}
public class EmployeeList {
	public static void main(String[] args) {
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
		ArrayList<Employee> employee = new ArrayList<>();
		employee.add(emp1);
        employee.add(emp2);
        employee.add(emp3);
        employee.add(emp4);
        employee.add(emp5);
        employee.add(emp6);
        Map<String, Long> count = employee.stream()
        .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
System.out.println("No of employees in each department " + count);

//average salary of male and female employees
Map<String, Double> avgSalary= employee.stream()
.collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
System.out.println(" average salary of male and female employees: "+avgSalary);

//details of the highest-paid employee in the organization from the given list of employees
Optional<Employee> highestPaidEmployee= employee.stream().max(Comparator.comparingDouble(Employee::getSalary));
System.out.println("Highest paid employee in the organization: "+highestPaidEmployee);
    

//average age of each department in an organization
Map<String, Double> avgAge= employee.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
System.out.println("Average age: "+avgAge);

//who is the senior-most employee in the organization in terms of experience
Optional<Employee> seniorMostEmployee= employee.stream().min(Comparator.comparingInt(Employee::getYearOfJoining));
System.out.println("Senior most employee in the organization: "+seniorMostEmployee);

//Get the details of the youngest employee in the organization.
Optional<Employee> youngestEmployee= employee.stream().min(Comparator.comparingDouble(Employee::getAge));
System.out.println("Youngest employee in the organization: "+youngestEmployee);

//Find out the number of male and female employees in the organization
Map<String, Long>  countMaleFemaleEmp= employee.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
System.out.println("Male and female employees"+countMaleFemaleEmp);
	}           
}

0 replies

Shivani2145 · 2022-08-28T05:05:23Z

Shivani2145
Aug 28, 2022

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

class Employee{
	 int id;
	    String name; 
	    int age;
	    String gender; 
	    String department;  
	    int yearOfJoining;
	    double salary;
	      
	    public Employee(int id, String name, int age, String gender, String department, int yearOfJoining, double salary) 
	    {
	        this.id = id;
	        this.name = name;
	        this.age = age;
	        this.gender = gender;
	        this.department = department;
	        this.yearOfJoining = yearOfJoining;
	        this.salary = salary;
	    }
	      
	    public int getId() 
	    {
	        return id;
	    }
	      
	    public String getName() 
	    {
	        return name;
	    }
	      
	    public int getAge() 
	    {
	        return age;
	    }
	      
	    public String getGender() 
	    {
	        return gender;
	    }
	      
	    public String getDepartment() 
	    {
	        return department;
	    }
	      
	    public int getYearOfJoining() 
	    {
	        return yearOfJoining;
	    }
	      
	    public double getSalary() 
	    {
	        return salary;
	    }
	      
	    @Override
	    public String toString() 
	    {
	        return "Id : "+id
	                +", Name : "+name
	                +", age : "+age
	                +", Gender : "+gender
	                +", Department : "+department
	                +", Year Of Joining : "+yearOfJoining
	                +", Salary : "+salary;
	    }
}
public class EmployeeList {
	public static void main(String[] args) {
		Employee emp1 = new Employee(3, "Vishal Singhal", 34, "male", "HR", 2013, 300000);
		Employee emp2 = new Employee(4, "Amitabh Singh", 35, "male", "Admin", 2014, 500000);
		Employee emp3 = new Employee(5, "Vivek Bhati", 28, "male", "Admin", 2017, 500000);
		Employee emp4 = new Employee(6, "Vipul Diwan", 34, "male", "Account", 2014, 200000);
		Employee emp5 = new Employee(7, "Satish Kumar", 29, "male", "Account", 2017, 75000);
		Employee emp6 = new Employee(8, "Geetika Chauhan", 30, "female", "Admin", 2016, 90000);
		ArrayList<Employee> employee = new ArrayList<>();
		employee.add(emp1);
        employee.add(emp2);
        employee.add(emp3);
        employee.add(emp4);
        employee.add(emp5);
        employee.add(emp6);
        Map<String, Long> count = employee.stream()
        .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));
System.out.println("No of employees in each department " + count);

//average salary of male and female employees
Map<String, Double> avgSalary= employee.stream()
.collect(Collectors.groupingBy(Employee::getGender, Collectors.averagingDouble(Employee::getSalary)));
System.out.println(" average salary of male and female employees: "+avgSalary);

//details of the highest-paid employee in the organization from the given list of employees
Optional<Employee> highestPaidEmployee= employee.stream().max(Comparator.comparingDouble(Employee::getSalary));
System.out.println("Highest paid employee in the organization: "+highestPaidEmployee);
    

//average age of each department in an organization
Map<String, Double> avgAge= employee.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.averagingDouble(Employee::getAge)));
System.out.println("Average age: "+avgAge);

//who is the senior-most employee in the organization in terms of experience
Optional<Employee> seniorMostEmployee= employee.stream().min(Comparator.comparingInt(Employee::getYearOfJoining));
System.out.println("Senior most employee in the organization: "+seniorMostEmployee);

//Get the details of the youngest employee in the organization.
Optional<Employee> youngestEmployee= employee.stream().min(Comparator.comparingDouble(Employee::getAge));
System.out.println("Youngest employee in the organization: "+youngestEmployee);

//Find out the number of male and female employees in the organization
Map<String, Long>  countMaleFemaleEmp= employee.stream().collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));
System.out.println("Male and female employees"+countMaleFemaleEmp);
	}           
}

0 replies

Task - Collection - Employee Statistics #57

Uh oh!

Uh oh!

akash-coded Mar 10, 2022 Maintainer

Replies: 39 comments

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Code

Uh oh!

Uh oh!

code

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

akash-coded
Mar 10, 2022
Maintainer