如何使用实现相同接口的不同对象对列表进行排序？

Question

我有一个抽象类：

public abstract class Employee implements Comparable<Employee>{
  public Double getSalary();


    @Override
    public Double compareTo(final Employee employee2) {
    }
}

扩展这个抽象类的两个类：

public class Manager {
  public Double getSalary(){}
}

public class Chef{
  public Double getSalary(){}
}

我想对它进行排序，以便列表中的所有 Chef 对象都在前面，然后在所有 Chef 对象之后，我希望 Manager 对象按照薪水最高的降序排序。换句话说，对于 Chef 对象，我只希望它们被推到列表的前面，没有别的。对于 Manager 对象，我希望它们按薪水排序，并放在 Chef 对象之后的列表末尾。

例如

Manager manager1 = new Manager(40000);
Manager manager2 = new Manager(50000);
Manager manager3 = new Manager(60000);
Chef chef1 = new Chef(25000);
Chef chef2 = new Chef(25500);
Chef chef3 = new Chef(28000);
Chef chef4 = new Chef(29000);
List<Employee> employees = new ArrayList<Employee>();
employees.add(manager3);
employees.add(manager1);
employees.add(chef1);
employees.add(chef3);
employees.add(manager2);
employees.add(chef4);
employees.add(chef2);

对列表中的元素进行排序后可能是这样的：

0. chef1 = 25000 // Chef objects pushed to front but not sorted by salary
1. chef3 = 28000
2. chef4 = 29000
3. chef2 = 25500
4. manager3 = 60000 // Manager objects pushed to the back and sorted by salary
5. manager2 = 50000
6. manager1 = 40000

我的 compareTo 方法：

@Override
public int compareTo(final Employee employee2) {
    if (this instanceof Manager|| employee2instanceof Manager) {
        return employee2.getSalary().compareTo(this.getSalary());
    }

    return -1;
}

但是，这会将 Manager 对象放在前面。我对如何在这个 compareTo 方法中使用 Chef 对象感到困惑。

Answer 1

您的情况听起来像是创建Comparator 比实现Comparable 更合适：后者专门用于建模类实例的自然顺序。

例如，Integer implements Comparable<Integer>：整数的自然排序非常明显。

您的案例听起来更像是您希望如何对它们进行排序的一次性案例，例如在特定报告中呈现。

此外，当父类需要了解其子类时，我认为这是一种代码异味。没有什么可以阻止新子类的创建；没有必要更新 Employee 来处理这个事实。

从一种转换到另一种很容易：不是将int compare(Employee that) 方法添加到Employee，而是在比较器中实现一个方法：

class ChefsAndManagersComparator implements Comparator<Employee> {
  @Override
  public int compare(Employee employee1, Employee employee2) {
    // The logic from any of the other answers,
    // just replacing "this" references with "employee1"
  }
}

Answer 2

您的代码无法编译，您不能在 getSalary 返回的原始 int 上调用 compareTo()...相反，您可以使用实用方法 Long.compare()

if (this instanceof Manager || employee2 instanceof Manager) {
    return Long.compare(this.getSalary(), employee2.getSalary());
}

另外，鉴于这不是“自然搜索顺序”，我会将其表示为 Comparator 而不是 Comparable...，即在 Employee 类的外部，而不是嵌入其中。

Collections.sort(employees, new Comparator<Employee>() {
    @Override
    public int compare(Employee o1, Employee o2) {
        if (o1 instanceof Manager && o2 instanceof Chef) {
            return 1;
        } else if (o1 instanceof Chef && o2 instanceof Manager) {
            return -1;
        } else if (o1 instanceof Chef && o2 instanceof Chef) {
            return 0;
        } else {
            return Long.compare(o1.getSalary(), o2.getSalary());
        }
    }
});

输出

Chef 25000
Chef 28000
Chef 29000
Chef 25500
Manager 40000
Manager 50000
Manager 60000

Answer 3

您可以创建自定义比较器并将其传递给Collections.sort(..)。一旦你有了比较器，你可以做Collections.sort(employees, new CustomComparator());。

以下是执行此操作的一种方法，但我不强烈建议这种做法，因为它可能会在运行时导致复杂性，甚至在检查/针对子类时出错。

public class CustomComparator implements Comparator<Employee> {
    @Override
    public int compare(Employee o1, Employee o2) {
        if(o1 instanceof Chef && o2 instanceof Manager)
            return -1;

        if(o1 instanceof Manager && o2 instanceof Chef)
            return +1;

        if(o1 instanceof Manager && o2 instanceof Manager) 
            return Double.compare(o1.getSalary(), o2.getSalary());

        return 0;
    }  
}

在我写这篇文章时，我认为更好的方法是使用多个列表来存储每个 Employee 类型。这将解决在运行时使用检查的问题。

或者，也许您可​​以在接口中实现一些字段，为每个实现类型提供不同的分数，然后可以用来比较 Employee 对象。

Answer 4

您可以使用 3 个列表，因此您不必检查特定的子类型：

List<Chef> chefs = new ArrayList<Chef>();
List<Manager> managers = new ArrayList<Manager>();

managers.add(manager3);
managers.add(manager1);
chefs.add(chef1);
chefs.add(chef3);
managers.add(manager2);
chefs.add(chef4);
chefs.add(chef2);

Collections.sort(managers);

List<Employee> employees = new ArrayList<Employee>();
employees.addAll(chefs);
employess.addAll(managers);

---

但是，如果您无法更改员工存储的实现方式，您仍然可以遍历员工列表，检查每种类型并插入到特定列表中。然后，在最后连接：

...
List<Chef> chefs = new ArrayList<Chef>();
List<Manager> managers = new ArrayList<Manager>();
List<Employee> others = new ArrayList<Employee>();

for(Employee e : employees) {
    if(e instanceof Chef)
        chefs.add(e);
    else if(e instanceof Manager)
        managers.add(e);
    else
        others.add(e);
}

Collections.sort(managers);

List<Employee> result = new ArrayList<Employee>();
result.addAll(chefs);
result.addAll(managers);
result.addAll(others);

ArrayList::addAll 使用 System::arrayCopy 所以它非常快。这也与使用比较器大致相同，但它可能更具可读性。这真的取决于偏好。