Question

我在找到按订单排序类的有效方法时遇到了问题。我的下面的代码完成了我需要排序的顺序，但我相信还有另一种方式（我不知道）。

什么是对类进行排序的有效方法？

public int compare(Object one, Object two)    
{  
          //S = Salaried, W = Weekly, D = Daily

          //SS == 0 -> SW == -1 -> SD == -1
          //WS == 1 -> WW == 0 -> WD == -1 
          //DS == 1 -> DW == 1 -> DD == 0

          Employee a = (Employee)one;
          Employee b = (Employee)two;

          SalariedEmployee s = new SalariedEmployee(0.0); 
          WeeklyEmployee w = new WeeklyEmployee (0.0);
          DailyEmployee d = new DailyEmployee();


          if(one.getClass() == s.getClass() && two.getClass() == s.getClass())
              return Double.compare(b.grossPay(), a.grossPay());

          if(one.getClass() == s.getClass() && two.getClass() == w.getClass())
              return -1;

          if(one.getClass() == s.getClass() && two.getClass() == d.getClass())
              return -1;

          if(one.getClass() == w.getClass() && two.getClass() == s.getClass())
              return 1;

          if(one.getClass() == w.getClass() && two.getClass() == w.getClass())
              return Double.compare(b.grossPay(), a.grossPay());

          if(one.getClass() == w.getClass() && two.getClass() == d.getClass())
              return -1;

          if(one.getClass() == d.getClass() && two.getClass() == s.getClass())
              return 1;

          if(one.getClass() == d.getClass() && two.getClass() == w.getClass())
              return 1;

          if(one.getClass() == d.getClass() && two.getClass() == d.getClass())
              return Double.compare(b.grossPay(), a.grossPay());

          return 0;

      }

Answer 1

实施Comparable＆lt;＆gt;您的类中的接口并覆盖Employee类中的compareTo()方法。该方法将Object类作为传递值。例如，

public class Employee implements Comparable<Employee> {
    //omitted

    public int compareTo(Employee other) {
        return grossPay.compareTo(other.grossPay);
    }
}

查看以下链接以了解详情 http://download.oracle.com/javase/tutorial/collections/interfaces/order.html

Answer 2

我在找到按订单排序类的有效方法时遇到问题

取决于“高效”的含义。从CPU的角度来看，将所有代码放在单个方法中将是最有效的（如果正确完成），但从灵活性的角度来看，它并不是非常有效。

如果方法不会很快但会更加灵活，请查看Group Comparator和Bean Comparator。

GroupComparator允许您将多个比较器组合成一种。 BeanComparator是一个通用比较器，允许您对给定类中的任何字段进行排序。因此，要使用GroupComparator，基本代码将是：

EmployeeComparator employee = new EmployeeComparator();
BeanComparator grossPay = new BeanComparator(Employee.class, "grossPay");
GroupComparator gc = new GroupComparator(employee, grossPay);
Collections.sort(list, gc);

因此，您需要编写一个Comparator，按薪水，每周和每日对员工进行排序。 EmployeeComparator的基本代码可能类似于：

if (one.getClass()equals(two.getClass())
    return 0;

if (one instanceOf SalariedEmployee)
    return 1;

if (two instanceOf SalariedEmployee)
   return -1;

if (one instanceOf WeeklyEmployee)
    return 1;
else
    return -1;

要设置一些工作，但是一旦有了EmployeeComparator，就可以使用Bean和Group Comparators对多个不同的属性进行排序。

Answer 3

这是我的解决方案。

public int compare(Employee left, Employee right) {
    int typeOrderLeft = getTypeOrder(left);
    int typeOrderRight = getTypeOrder(right);

    if (typeOrderLeft == typeOrderRight) {
        return Double.compare(left.grossPay(), right.grossPay());
    } else {
        return typeOrderLeft - typeOrderRight;
    }
}

private int getTypeOrder(Employee employee) {
    if (employee instanceof DailyEmployee) {
        return 1;
    } else if (employee instanceof WeeklyEmployee) {
        return 2;
    } else if (employee instanceof SalaryEmployee) {
        return 3;
    }

    return 0;
}

Answer 4

您需要先实现类似的界面。这允许您定义一个compareTo方法，该方法可用于根据您认为可用于比较类的特定值对类进行排序。

定义compareTo方法对于没有预定义比较方式的对象非常有用。

你如何比较订单的类？

4 个答案: