Question

我有两个数组列表。每个都有Employee类型的对象列表。

Employee类如下所示

    public class Employee {

    private int id; // this is the primary key from employee table

    private String firstname;

    private String lastname;

    private String employeeId; // manually assigned unique id to each employee

    private float fte;

    Employee(String firstname, String lastname, String employeeId, float fte) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.employeeId = employeeId;
        this.fte = fte;
    }

    // getters and setters
}

员工ID是为每位员工手动生成的唯一ID。

我需要根据具有不同fte的员工ID找到两个列表之间的普通员工。

    import java.util.ArrayList;
import java.util.List;

public class FindFTEDifferencesBetweenMatchingEmployeeIds {

    public static void main(String args[]) {
        List<Employee> list1 = new ArrayList<Employee>();
        List<Employee> list2 = new ArrayList<Employee>();

        list1.add(new Employee("F1", "L1", "EMP01", 1));
        list1.add(new Employee("F2", "L2", "EMP02", 1));
        list1.add(new Employee("F3", "L3", "EMP03", 1));
        list1.add(new Employee("F4", "L4", "EMP04", 1));
        list1.add(new Employee("F5", "L5", "EMP05", 1));
        list1.add(new Employee("F9", "L9", "EMP09", 0.7F));

        list2.add(new Employee("F1", "L1", "EMP01", 0.8F));
        list2.add(new Employee("F2", "L2", "EMP02", 1));
        list2.add(new Employee("F6", "L6", "EMP06", 1));
        list2.add(new Employee("F7", "L7", "EMP07", 1));
        list2.add(new Employee("F8", "L8", "EMP08", 1));
        list2.add(new Employee("F9", "L9", "EMP09", 1));

        List<FTEDifferences> commonInBothListWithDifferentFTE = new ArrayList<FTEDifferences>();
        // this should contain EMP01 and EMP09
        // since EMP02 has same FTE in both lists, it is ignored. 


    }
}

员工ID为EMP01和EMP09的员工在两个列表中都很常见，并且每个列表中的ftes也不同。

所以，我想要另一个包含这两名员工的清单。

    public class FTEDifferences {

    private Employee fromList1;

    private Employee fromList2;

    public Employee getFromList1() {
        return fromList1;
    }

    public void setFromList1(Employee fromList1) {
        this.fromList1 = fromList1;
    }

    public Employee getFromList2() {
        return fromList2;
    }

    public void setFromList2(Employee fromList2) {
        this.fromList2 = fromList2;
    }
}

请帮忙。

PS。即使在SQL中很容易做到这一点，我也无法在SQL查询中执行此操作，因为我无法修改查询。我只需要处理两个给定的列表。 :(

Answer 1

将equals()，hashcode()和compareTo()方法添加到您的Employee课程中。然后，您可以尝试从retainAll()静态类设置removeAll()或Collections等操作。

如果要在任何时候以任何方式比较这些方法，最好将这些方法添加到类中。

Answer 2

覆盖hashcode和equals（）方法

Answer 3

覆盖equals方法，如下所示。

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Employee other = (Employee) obj;
    if (employeeId == null) {
        if (other.employeeId != null)
            return false;
    } else if (!employeeId.equals(other.employeeId))
        return false;
    if (firstname == null) {
        if (other.firstname != null)
            return false;
    } else if (!firstname.equals(other.firstname))
        return false;
    if (Float.floatToIntBits(fte) == Float.floatToIntBits(other.fte))
        return false;
    if (lastname == null) {
        if (other.lastname != null)
            return false;
    } else if (!lastname.equals(other.lastname))
        return false;
    return true;
}

然后创建finalList列表并向其添加list1。然后使用finalList在list2列表中调用 retainAll ，这将基于Employees

为您提供常见的employeeId

   List<Employee> finalList=new ArrayList<Employee>();
    finalList.addAll(list1);
    finalList.retainAll(list2);
    List<Employee> commonInBothListWithDifferentFTE=finalList;
    System.out.println(commonInBothListWithDifferentFTE);

<强>输出：

[Employee [firstname=F1, lastname=L1, employeeId=EMP01, fte=1.0], Employee [firstname=F9, lastname=L9, employeeId=EMP09, fte=0.7]]

Answer 4

如果Employee的最大数量大约为500或甚至1000，则只需使用双嵌套循环。它应该足够快。该方法的时间复杂度为O（mn），其中m和n是2个列表的大小。

如果您希望员工的最大数量为3000或更多，您可以考虑以下两种方法：

另一种方法是根据员工编号的字典顺序对两个列表进行排序（实现Comparator），并使用单个循环同时循环遍历两个列表。复杂性为O（mlog m + nlog n）。

如果想要更优化，可以使用HashSet（覆盖equals和hashCode）并将一个列表的所有元素放在HashSet中。您现在可以遍历其他列表并从第一个列表中选择相同的员工并进行比较。摊销的复杂性为O（m + n）。

如何在两个不同属性的数组列表中找到普通员工？

4 个答案: