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

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

    // 构造函数、Getter/Setter省略
}

public static boolean containsAnyNaive(List<EmployeeData> allEmployees, List<EmployeeData> currentEmployees) {
    for (EmployeeData allEmployee : allEmployees) {
        for (EmployeeData 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; // 找到匹配项，立即返回
            }
        }
    }
    return false; // 未找到任何匹配项
}

import java.util.Objects; // 导入java.util.Objects简化equals和hashCode实现

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

    // 构造函数
    public EmployeeData(String name, String lastName, String joiningDate, String promotionDate) {
        this.name = name;
        this.lastName = lastName;
        this.joiningDate = joiningDate;
        this.promotionDate = promotionDate;
    }

    // Getter方法（为简洁省略Setter）
    public String getName() { return name; }
    public String getLastName() { return lastName; }
    public String getJoiningDate() { return joiningDate; }
    public String getPromotionDate() { return promotionDate; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 同一对象
        if (o == null || getClass() != o.getClass()) return false; // null或不同类型

        EmployeeData other = (EmployeeData) o; // 类型转换
        return Objects.equals(name, other.name) &&
               Objects.equals(lastName, other.lastName) &&
               Objects.equals(joiningDate, other.joiningDate) &&
               Objects.equals(promotionDate, other.promotionDate);
    }

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

    @Override
    public String toString() {
        return "EmployeeData{" +
               "name='" + name + '\'' +
               ", lastName='" + lastName + '\'' +
               ", joiningDate='" + joiningDate + '\'' +
               ", promotionDate='" + promotionDate + '\'' +
               '}';
    }
}

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

public class EmployeeComparator {

    public static boolean containsAnyOptimized(List<EmployeeData> allEmployees,
                                               List<EmployeeData> currentEmployees) {
        // 1. 将allEmployees放入HashSet。这一步的时间复杂度为O(N)，N为allEmployees的大小。
        Set<EmployeeData> allEmpSet = new HashSet<>(allEmployees);

        // 2. 遍历currentEmployees，对每个元素进行查找。
        //    HashSet的contains()操作平均时间复杂度为O(1)。
        //    因此，这一步的时间复杂度为O(M)，M为currentEmployees的大小。
        for (EmployeeData currentEmployee : currentEmployees) {
            if (allEmpSet.contains(currentEmployee)) {
                return true; // 找到匹配项，立即返回
            }
        }
        return false; // 未找到任何匹配项
    }
}

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

public class EmployeeComparator {

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

        // 使用anyMatch()方法，只要找到一个匹配的元素就返回true
        return currentEmployees.stream().anyMatch(allEmpSet::contains);
    }
}

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

public class EmployeeComparator {

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

        // containsAll()方法会检查当前集合是否包含指定集合中的所有元素。
        // 其内部逻辑也是对指定集合的每个元素进行contains()查找。
        // 时间复杂度为O(N + M)。
        return allEmpSet.containsAll(currentEmployees);
    }
}