Java中利用HashSet优化嵌套循环：实现O(N)时间复杂度的对象列表比较

for (EmployeeDatas allEmployee : allEmployees) {
    for (EmployeeDatas currentEmployee : currentEmployees) {
         if (allEmployee.name.equals(currentEmployee.name) &&   
             allEmployee.lastName.equals(currentEmployee.lastName) && 
             allEmployee.joiningDate.equals(currentEmployee.joiningDate) &&
             allEmployee.promotionDate.equals(currentEmployee.promotionDate)) {
             return true; // 找到匹配项
         }
    }
}

import java.util.Objects;

public class EmployeeData {
    private String name;
    private String lastName;
    private String joiningDate;
    private String promotionDate;

    // 构造函数、Getter/Setter方法省略

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EmployeeData other = (EmployeeData) o;
        return Objects.equals(this.name, other.name) &&
               Objects.equals(this.lastName, other.lastName) &&
               Objects.equals(this.joiningDate, other.joiningDate) &&
               Objects.equals(this.promotionDate, other.promotionDate);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, lastName, joiningDate, promotionDate);
    }
}

import java.util.List;
import java.util.HashSet;
import java.util.Set;

public class EmployeeComparator {

    /**
     * 检查 currentEmployees 列表中是否存在任意一个员工在 allEmployees 列表中。
     *
     * @param allEmployees 包含所有员工数据的列表。
     * @param currentEmployees 待比较的员工数据列表。
     * @return 如果找到任意匹配项，则返回 true；否则返回 false。
     */
    public static boolean containsAny(List<EmployeeData> allEmployees,
                                      List<EmployeeData> currentEmployees) {
        // 将 allEmployees 转换为 HashSet，以便进行 O(1) 的查找
        Set<EmployeeData> allEmpSet = new HashSet<>(allEmployees);

        // 遍历 currentEmployees，检查是否存在于 allEmpSet 中
        for (EmployeeData currentEmployee : currentEmployees) {
            if (allEmpSet.contains(currentEmployee)) {
                return true; // 找到第一个匹配项后立即返回
            }
        }
        return false;
    }
}

import java.util.List;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;

public class EmployeeComparator {

    public static boolean containsAnyWithStream(List<EmployeeData> allEmployees,
                                                List<EmployeeData> currentEmployees) {
        Set<EmployeeData> allEmpSet = new HashSet<>(allEmployees);

        // 使用 Stream API 的 anyMatch 方法进行查找
        return currentEmployees.stream().anyMatch(allEmpSet::contains);
    }
}

import java.util.List;
import java.util.HashSet;
import java.util.Set;

public class EmployeeComparator {

    /**
     * 检查 currentEmployees 列表中的所有员工是否都在 allEmployees 列表中。
     *
     * @param allEmployees 包含所有员工数据的列表。
     * @param currentEmployees 待比较的员工数据列表。
     * @return 如果 currentEmployees 中的所有员工都在 allEmployees 中，则返回 true；否则返回 false。
     */
    public static boolean containsAll(List<EmployeeData> allEmployees,
                                      List<EmployeeData> currentEmployees) {
        // 将 allEmployees 转换为 HashSet
        Set<EmployeeData> allEmpSet = new HashSet<>(allEmployees);

        // 使用 containsAll() 方法检查所有元素是否存在
        return allEmpSet.containsAll(currentEmployees);
    }
}