2

我有两个数组列表。每个都有 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 查询中执行此操作，因为我无法修改查询。我只需要处理两个给定的列表。:(

4

4 回答 4

1

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

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

于 2012-07-19T06:54:50.593 回答
0

覆盖 hashcode 和 equals() 方法

于 2012-07-19T06:55:28.967 回答
0

覆盖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到它。然后在列表上调用retainAll ，这将为您提供基于finalListlist2EmployeesemployeeId

   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]]
于 2012-07-19T07:21:22.717 回答
0

如果 Employee 的最大数量在 500 甚至 1000 左右，只需使用双重嵌套循环即可。它应该足够快。此方法的时间复杂度为 O(mn)，其中 m 和 n 是 2 个列表的大小。

如果您期望 Employee 的最大数量为 3000 甚至更多，您可以考虑以下 2 种方法：

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

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

于 2012-07-19T08:21:31.473 回答