Java Sorting logic and Identifying max of two objects

The requirement is to find the latest employee objects (latest date) having group number 8 with department 2 and having group number 4 within department 2. Same way group number 8 within department 1 and group number 4 in department 1. I only need the latest one object of all the above in the final list.

The comparison logic written was to sort it on the required order and retain only the required object. But I am stuck as I cannot find a way to retain single object from the sorted list. Is there anyway i can achieve it? Ignore the Comparator logic, appreciate if you can suggest any ootb way using stream or other good implementation?

  SimpleDateFormat df = new SimpleDateFormat("dd-mm-yyyy");
List<Employee> employees = new LinkedList<Employee>(Arrays.asList(
new Employee("Emp1", df.parse("12-08-2020"),
new EmpType("1", new Group(8))),
new Employee("Emp2", df.parse("11-08-2020"),
new EmpType("2", new Group(8))),
new Employee("Emp3", df.parse("10-08-2020"),
new EmpType("2", new Group(4))),
new Employee("Emp4", df.parse("17-08-2020"),
new EmpType("2", new Group(8))),
new Employee("Emp5", df.parse("19-08-2020"),
new EmpType("1", new Group(4)))));
/* Sorting logic to sort by group number first then by department and then by date */
Collections.sort(employees, new Comparator<Employee>() {
@Override
public int compare(Employee employee, Employee t1) {
int val = 0;
if (employee.getEmpType().getGroup().getNumber() < t1.getEmpType().getGroup().getNumber()) {
val = 1;
} else if (employee.getEmpType().getGroup().getNumber() > t1.getEmpType().getGroup()
.getNumber()) {
val = -1;
} else {
val = 0;
}
if (val == 0) {
val = -(employee.getEmpType().getDepartment().compareTo(t1.getEmpType().getDepartment()));
}
if (val == 0) {
val = -employee.getDate().compareTo(t1.getDate());
}
return val;
}
});

Instead of sorting, you could use Collections.max with the same Comparator you've implemented.

EDIT to address the discussion in the comments:<br/>
If I understand the data structure correctly, EmpType encapsulates the unique combination we want to find the "latest" employee for. Assuming it has a proper implementation of the equals(Object) and hashCode() methods, you could stream the list and collect it to a map from the EmpType to the latest employee:

Map<EmpType, Employee> latestEmployees =
    employees.stream()
             .collect(Collectors.toMap(
                          Employee::getEmpType,
                          Function.identity(),
                          BinaryOperator.maxBy(
                              Comparator.comparing(Employee::getDate))));



</details>



# 答案2
**得分**: 1

我觉得在排序函数内部混合业务逻辑相当混乱。

为什么不只是根据员工的日期降序排列，然后在结果数组中遍历，直到第一次满足您的条件为止？

<details>
<summary>英文:</summary>

I find it quite messy to mix the business logic inside the sort function. 

Why not just sort the Employees descendingly accoring to their date and parse through the resulting array untill your conditions are met for the first time?

</details>



# 答案3
**得分**: 1

你可以使用 Stream API 的 `Collectors.toMap` 方法，按照 `EmpType` 进行分组，并使用 `BinaryOperator.maxBy` 获取每个具有相同 `EmpType` 的分组的最新日期作为值。然后将 map 的值取出，放入一个新的 `ArrayList` 中。在这里按照 `EmpType` 进行分组，因为它包含了组号和部门信息，你需要为 `EmpType` 实现适当的 `equals` 和 `hashcode` 方法。

```java
List<Employee> res = new ArrayList(employees.stream()
    .collect(Collectors.toMap(Employee::getEmpType, Function.identity(),
        BinaryOperator.maxBy(Comparator.comparing(Employee::getDate)))).values());

或者你可以创建一对组号和部门的组合作为键，例如使用 new AbstractMap.SimpleEntry(e.getEmpType().getDepartment(), e.getEmpType().getGroup().getNumber())，代替使用 EmpType 作为键，这样就不需要实现 equals 和 hashcode 方法。

List<Employee> res = new ArrayList(employees.stream()
    .collect(Collectors.toMap(
                     e -> new AbstractMap.SimpleEntry(e.getEmpType().getDepartment(),
                                              e.getEmpType().getGroup().getNumber()),
                              Function.identity(),
                    BinaryOperator.maxBy(Comparator.comparing(Employee::getDate))))
    .values());

List<Employee> res = new ArrayList(employees.stream()
.collect(Collectors.toMap(Employee::getEmpType, Function.identity(),
BinaryOperator.maxBy(Comparator.comparing(Employee::getDate)))).values());

List<Employee> res = new ArrayList(employees.stream()
.collect(Collectors.toMap(
e -> new AbstractMap.SimpleEntry(e.getEmpType().getDepartment(),
e.getEmpType().getGroup().getNumber()),
Function.identity(),
BinaryOperator.maxBy(Comparator.comparing(Employee::getDate))))
.values());