如何对不同类类型的对象数组进行排序？

Question

我正在尝试开发一个程序，该程序可以对具有不同类类型但彼此处于相同层次结构的对象数组进行排序。所有对象都列在我要排序的同一个数组中，虽然我可以很容易地按字母顺序对相同类型的对象数组进行排序，但我无法弄清楚如何一次对所有对象进行排序Arrays.sort() 方法。任何人都可以提供任何帮助，我们将不胜感激。

import java.util.Arrays;

public class Driver {

public static void main(String[] args) {

    Vehicle[] machines = new Vehicle[3];//Example of an array that I can sort
    machines[0] = new Vehicle("Giant Robot");
    machines[1] = new Vehicle("Time Machine");
    machines[2] = new Vehicle("Airplane");
    Arrays.sort(machines);
    for (int i = 0; i < machines.length; i++)
        System.out.println(machines[i].getName());


    Vehicle[] vehicles = new Vehicle[7];//example of an array that I cannot sort
    vehicles[0] = new Car("Batmobile", 10);
    vehicles[1] = new Helicopter("Batcopter", "x");
    vehicles[2] = new Car("Jaguar", 6);
    vehicles[3] = new Helicopter("RC Copter", "t");
    vehicles[4] = new Car("Accelerator", 6);
    vehicles[5] = new Helicopter("Stormshadow", "z");
    vehicles[6] = new Car("Batmobile", 11);
}

}

**

public class Vehicle implements Comparable {
private String name;

public Vehicle(){
    name = "no name";
}

public Vehicle(String newName){
    name = newName;
}

public String getName(){
    return name;
}

public int compareTo(Object o)
{
    if ((o != null) &&
        (o instanceof Vehicle))
    {
        Vehicle otherVehicle = (Vehicle) o;
        return (name.compareTo(otherVehicle.name));
    }
    return -1;
}

}

**

public class Car extends Vehicle {

private int tireSize;

public Car(){
    super();
    tireSize = 0;
}

public Car(String newName, int newTireSize){
    super(newName);
    tireSize = newTireSize;
}

public int getSize(){
    return tireSize;
}

}

**

public class Helicopter extends Vehicle {

private String bladeType;

public Helicopter(){
    super();
    bladeType = "none";
}

public Helicopter(String newName, String newBlade){
    super(newName);
    bladeType = newBlade;
}

public String getType(){
    return bladeType;
}

}

Answer 1

目标：您需要能够将Vehicle 与其他Vehicle 进行比较。

为实现该目标：

public class Vehicle implements Comparable<? extends Vehicle> {

    ....

    public int compareTo(Object o) {
        // Now, that the Comparable is for the type Vehicle
        // you know that o is some kind of vehicle

        // check vehicle related things
        // number of seats, dogs, whatever
        return -1;
    }

}

Answer 2

您只需将代码调整为：

class Vehicle implements Comparable<Vehicle> {

    private String name;

    /* ... */

    @Override
    public int compareTo(Vehicle vehicle) {
        return name.compareTo(vehicle.getName());
    }
}

Answer 3

在大多数情况下，你的类不应该实现Comparable，除非有一个且只有一个总是正确的排序，比如数字。您的车辆可以按名称、年龄以及可能更多的标准进行排序，因此它们不应实现Comparable。

相反，您可以在实际对车辆进行排序时将排序函数作为 lambda 函数传递：

Arrays.sort(machines, (left, right) -> left.getName().compareTo(right.getName()));

或者，等效地：

Arrays.sort(machines, Comparator.comparing(Vehicle::getName));

这样你就不再需要implements Comparable了。

Answer 4

如果要按车辆类型排序，则需要在对元素进行排序时考虑类类型。修改compareTo()方法如下图：

public int compareTo(Object o){
    if ((o != null) &&
        (o instanceof Vehicle)){
        Vehicle otherVehicle = (Vehicle) o;
        return (otherVehicle.getClass().getSimpleName().equals(this.getClass().getSimpleName()) ? 
                name.compareTo(otherVehicle.name) 
                : otherVehicle.getClass().getSimpleName().compareTo(this.getClass().getSimpleName()));
    }
    return -1;
}