public static void main(String[] args) {

List<Employee> employees = EmployeeDataBase.getAllEmployees();

// forEach

//employees.forEach(e-> System.out.println(e.getName()+" : "+e.getSalary()));

//employees.stream().forEach(System.out::println);

//filter

//.collect

Map<Integer, String> developmentEmployees = employees.stream()

.filter(e -> e.getDept().equals("Development") && e.getSalary() > 80000)

.collect(Collectors.toMap(Employee::getId, Employee::getName));

// System.out.println(developmentEmployees);

//map

//distinct

List<String> depts = employees.stream()

.map(Employee::getDept)

.distinct()

.collect(Collectors.toList());

//System.out.println(depts);

List<Stream<String>> projectNames = employees.stream()

.map(e -> e.getProjects()

.stream().map(p -> p.getName())).collect(Collectors.toList());

//flatMap

List<String> projects = employees.stream()

.flatMap(e -> e.getProjects().stream())

.map(p -> p.getName()).distinct()

.collect(Collectors.toList());

//System.out.println(projects);

//sorted

//asc

List<Employee> ascSortedEmployees = employees.stream()

.sorted(Comparator.comparing(Employee::getSalary))

.collect(Collectors.toList());

//ascSortedEmployees.forEach(System.out::println);

//desc

List<Employee> descSortedEmployees = employees.stream()

.sorted(Collections.reverseOrder(Comparator.comparing(Employee::getSalary)))

.collect(Collectors.toList());

//descSortedEmployees.forEach(System.out::println);

//min & max

Optional<Employee> highestPaidEmployees = employees.stream()

.max(Comparator.comparingDouble(Employee::getSalary));

// System.out.println("Highest paid employee : "+highestPaidEmployees);

Optional<Employee> lowestPaidEmployees = employees.stream()

.min(Comparator.comparingDouble(Employee::getSalary));

//System.out.println("Lowest paid employee : "+lowestPaidEmployees);

//groupingBy

Map<String, List<Employee>> employeeGroup = employees.stream()

.collect(Collectors.groupingBy(Employee::getGender));

//System.out.println(employeeGroup);

//Gender -> [names]

Map<String, List<String>> employeeGroupNames = employees.stream()

.collect(Collectors.groupingBy(Employee::getGender,

Collectors.mapping(Employee::getName, Collectors.toList())

));

//System.out.println(employeeGroupNames);

//Gender -> [count]

Map<String, Long> employeeGroupCountMap = employees.stream()

.collect(Collectors.groupingBy(Employee::getGender, Collectors.counting()));

System.out.println(employeeGroupCountMap);

//findFirst

Employee findFirstElement = employees.stream()

.filter(e -> e.getDept().equals("Development"))

.findFirst()

.orElseThrow(()->new IllegalArgumentException("Employee not found "));

//System.out.println(findFirstElement);

//findAny

Employee findAnyElement = employees.stream()

.filter(e -> e.getDept().equals("Development"))

.findAny()

.orElseThrow(()->new IllegalArgumentException("Employee not found "));

// System.out.println(findAnyElement);

//anyMatch(Predicate) , allMatch(Predicate) , noneMatch(Predicate)

boolean developmentEmpAnyMatch = employees.stream()

.anyMatch(e -> e.getDept().equals("Development"));

//System.out.println("is there any employee match from development dept "+developmentEmpAnyMatch);

boolean developmentEmpAllMatch = employees.stream()

.allMatch(e -> e.getSalary()>50000);//55000

//System.out.println(developmentEmpAllMatch); //false

boolean isNoneMatch = employees.stream()

.noneMatch(e -> e.getDept().equals("abc"));

//System.out.println(isNoneMatch);

//limit(long)

List<Employee> topPaidEmployees = employees.stream()

.sorted(Comparator.comparing(Employee::getSalary).reversed())

.limit(4)

.collect(Collectors.toList());

topPaidEmployees.forEach(e-> System.out.println(e.getName()));

//skip(long)

List<Employee> skipEmployees = employees.stream().skip(10)

.collect(Collectors.toList());

}