如何对多个字段对象使用比较器？

Question

我试图使用接口比较器来排序一个优先级队列，这样乘客的oorder就取决于他们是否有残疾，然后取决于他们的车票类型，最后取决于到达时间。

import java.util.*;

public static void main(String[] args){
    Random rand = new Random(System.nanoTime());
    Comparator<Passenger> comparator;
    PriorityQueue<Passenger> queue = new PriorityQueue<Passenger>(10, comparator);
    Passenger pass[] = new Passenger [10];


    for (int i=0; i<10;i++){
        int time1 = 0;
        pass[i] = new Passenger(rand.nextInt(100000000), rand.nextInt(3) , rand.nextBoolean(), time1);
        time1 = time1 + 15;
    }   

}

在这里，我初始化了乘客的数组，下面是乘客级别和比较方法：

public class Passenger implements Comparator<Passenger>{

private int ID;
private int clase;
private boolean disability;
private int arrivalTime;

public Passenger(int ID, int clase, boolean disability, int arrivalTime) {

    this.ID = ID;
    this.clase = clase; // 0-vip 1-economy 2-economy
    this.disability = disability;
    this.arrivalTime = arrivalTime;
}
public int getID() {
    return ID;
}
public void setID(int iD) {
    ID = iD;
}
public int getClase() {
    return clase;
}
public void setClase(int clase) {
    this.clase = clase;
}
public boolean isDisability() {
    return disability;
}
public void setDisability(boolean disability) {
    this.disability = disability;
}
public int getArrivalTime() {
    return arrivalTime;
}
public void setArrivalTime(int arrivalTime) {
    this.arrivalTime = arrivalTime;
}

public int compare(Passenger pas1, Passenger pas2) {
    if((pas1.isDisability()) && (!pas2.isDisability())){
        return 1;                       //passenger 1 has disability
    }else if((!pas1.isDisability()) && (pas2.isDisability())){
        return -1;                          //passenger 2 has disability 
    }
    else{                                   //both have disability or no one has disability 
        if(pas1.getClase() < pas2.getClase()){
            return 1;                   // passenger 1 has better class
        }else if(pas1.getClase() > pas2.getClase()){
            return -1;                      // passenger 2 has better class
        }
        else{                               //both have disability and same class
            if(pas1.getArrivalTime() < pas2.getArrivalTime()){
                return 1;               //passenger 1 arrived before passenger 2
            }
            else return -1;                 //passenger 2 arrived before passenger 1 
        }
    }
}

如何更好地处理这些多层次的比较?

Answer 1

您的问题似乎是简化比较，但我认为您宁愿实现Comparable<Passenger>而不是Comparator，并使用#compareTo方法。至于清理，如果您只是抽象实际的布尔逻辑，那么这也有点容易：

public int compareTo(Passenger other) {
    if (this.isDisability() ^ other.isDisability()) { //use an XOR
        return this.isDisability() ? 1 : -1; //1 for us, -1 for other
    }
    //compare #getClase
    int clase = -Integer.compare(this.getClase(), other.getClase()); //invert
    if (clase == 0) {
        //compare arrival times if clase is equal
        //normalize to -1, 1 (0 excluded in OP)
        return this.getArrivalTime() < other.getArrivalTime() ? 1 : -1;
    }
    return clase > 0 ? 1 : -1; //normalize to -1, 0, 1
}

这允许您定义到Passenger的自然排序，并且是封装/内部到您的类实现(不需要那么多的公开)。

这也使得像排序这样的操作更加容易：

List<Passenger> passengers = /* some list */;
Collections.sort(passengers);

如果您想提供一个可以完成其他排序的比较器，也可以在您的类中这样做：

public class Passenger {

    //...

    public static class ArrivalComparator implements Comparator<Passenger> {

        public int compare(Passenger one, Passenger two) {
            return Integer.compare(one.getArrivalTime(), two.getArrivalTime());
        }
    }

    //...

}

使用前面的示例，您可以根据到达时间对所有乘客进行排序：

Collections.sort(passengers, new Passenger.ArrivalComparator());

此外，可以使用Java 8将其内联：

//Sort by arrival time
Collections.sort(passengers, (one, two) -> Integer.compare(one.getArrivalTime(), two.getArrivalTime());

但总的来说，请记住，比较器主要用于定义特定的排序，而Comparable则定义一般/自然排序。

Answer 2

我认为您正在寻找的是重构您的代码，我建议将compare逻辑分离为一个单独的PassengerComparator类(SRP)，以便更好地维护和可读性，如下所示。

public class PassengerComparator implements Comparator<Passenger> {

      public int compare(Passenger pas1, Passenger pas2) {    
        //check the comparison of all
        if(disabilityComparator(Passenger pas1, Passenger pas2) 
              && arrivalTimeComparator(Passenger pas1, Passenger pas2) 
              && claseComparator(Passenger pas1, Passenger pas2)) {
            return 1;
        } else {
            return -1;
        }
      }

     //compares only disability 
     private int disabilityComparator(Passenger pas1, Passenger pas2) {
            return pas1.isDisability() - pas2.isDisability();
     }

     //compares only arrivalTime 
     private int arrivalTimeComparator(Passenger pas1, Passenger pas2) {
            return pas1.getArrivalTime() - pas2.getArrivalTime();
     }  

     //compares only clase
     private int claseComparator(Passenger pas1, Passenger pas2) {
            return pas1.getClase() - pas2.getClase();
     }
}

使用：

PriorityQueue<Book> queue = new PriorityQueue<Book>(10, new PassengerComparator());

Answer 3

如何更好地处理这些多层次的比较？

1. 为每个属性创建单独的比较器。
2. 将单个比较器合并成多个级别的比较。有关此方法的示例，请查看组比较器。

因此，要知道您有可重用的代码，它允许您按照您希望的任何顺序进行排序，而无需编写复杂的多级比较器。

您还可能希望查看Bean比较器，这使得在一行代码中创建单独的比较器变得很容易。