Java 如何对类中的对象数组进行排序

我有一个堆排序代码，它最初是用来对整数数组进行排序的，但我需要对类中的对象[]进行排序。我在这些行中不断遇到此错误：

public static void heapSort(Object[] myArray, int length) {
      Object temp;
      int size = length-1;
      for (int i = (length / 2); i >= 0; i--) {
         heapify(myArray, i, size);
      };
      for(int i= size; i>=0; i--) {
         temp = myArray[0];
         myArray[0] = myArray[size];
         myArray[size] = temp;
         size--;
         heapify(myArray, 0, size);
      }
   }

public static void heapify (Object [] myArray, int i, int heapSize) {
      int a = 2*i;
      int b = 2*i+1;
      int largestElement;
      if (a<= heapSize && myArray[a] > myArray[i]) {
         largestElement = a;
      } else {
         largestElement = i;
      }
      if (b <= heapSize && myArray[b] > myArray[largestElement]) {
         largestElement = b;
      }
      if (largestElement != i) {
         Object temp = myArray[i];
         myArray[i] = myArray[largestElement];
         myArray[largestElement] = temp;
         heapify(myArray, largestElement, heapSize);
     }
   }

publicstaticvoidheapsort（Object[]myArray，int-length）{
对象温度；
int size=length-1；
对于（int i=（长度/2）；i>=0；i--）{
heapify（myArray，i，size）；
};
对于（int i=size；i>=0；i--）{
temp=myArray[0]；
myArray[0]=myArray[size]；
myArray[大小]=温度；
大小--；
heapify（myArray，0，size）；
}
}
公共静态void heapify（对象[]myArray，int i，int heapSize）{
int a=2*i；
int b=2*i+1；
int大元素；
if（一个myArray[i]）{
最大元素=a；
}否则{
最大元素=i；
}
if（b myArray[largestElement]）{
最大元素=b；
}
if（最大元素！=i）{
对象温度=myArray[i]；
myArray[i]=myArray[largestElement]；
myArray[largestElement]=温度；
heapify（myArray，最大元素，heapSize）；
}
}

Sort.java:25:错误：二进制运算符'>'的操作数类型错误 if（一个myArray[i]）{
第一类：对象 第二类：对象 Sort.java:30:错误：二进制运算符'>'的操作数类型错误 if（b myArray[largestElement]）{
第一类：对象 第二类：对象

这个错误是什么意思，我以为是括号的位置，但它没有纠正错误

---

是否有更好的排序算法来对从类创建的对象数组进行排序。

您不能使用“>”来比较对象。请尝试在对象的类中实现接口，以便可以使用

.compareTo（）

。如果这样做，您也可以使用

数组.sort（yourArray）

对数组进行排序而不必担心实现。

不能使用“>”来比较对象。请尝试在对象的类中实现接口，以便可以使用

.compareTo（）

。如果这样做，也可以使用

数组.sort（yourArray）

对数组进行排序而不必担心实现。

也许最简单的方法是定义一个比较器来处理实际的 您正在比较的对象

假设您有一个SomeClass对象数组。您可以通过这种方式比较它们

Object[] objects = {new SomeClass(1), new SomeClass(6), new SomeClass(3),
                new SomeClass(4), new SomeClass(3), new SomeClass(5)};
        
Comparator<Object> comp = (ob1, ob2) -> { 
                   int i1 = ((SomeClass)ob1).id;
                   int i2 = ((SomeClass)ob2).id;
                         return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;};
                             
Arrays.sort(objects, comp);
System.out.println(Arrays.toString(objects));

上述

比较器

的工作原理是，只要比较器进行1）适当的强制转换，以及2）比较被比较的实际对象的适当项，就可以使用任何类型的对象数组。这需要将比较器传递到排序例程（例如

您的堆排序

）并通过调用

comp.compare（a，b）

使用，其中

a

和

b

是数组项

一个明显更好的方法是使用泛型，只接受实现answer中所述的

Comparable

接口的类型。在这种情况下，每个类都有适当的逻辑，可以按照设计人员的意图比较类的一个或多个方面。然后，所需的就是传递对象（在您的例子中是数组）到排序方法

class SomeClass {
    public int id;
    public SomeClass(int id) {
        this.id = id;
    }
    public String toString() {
        return id+"";
    }
}

---

也许最简单的方法是定义一个比较器来处理实际的 您正在比较的对象

假设您有一个SomeClass对象数组。您可以通过这种方式比较它们

Object[] objects = {new SomeClass(1), new SomeClass(6), new SomeClass(3),
                new SomeClass(4), new SomeClass(3), new SomeClass(5)};
        
Comparator<Object> comp = (ob1, ob2) -> { 
                   int i1 = ((SomeClass)ob1).id;
                   int i2 = ((SomeClass)ob2).id;
                         return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;};
                             
Arrays.sort(objects, comp);
System.out.println(Arrays.toString(objects));

上述

比较器

的工作原理是，只要比较器进行1）适当的强制转换，以及2）比较被比较的实际对象的适当项，就可以使用任何类型的对象数组。这需要将比较器传递到排序例程（例如

您的堆排序

）并通过调用

comp.compare（a，b）

使用，其中

a

和

b

是数组项

一个明显更好的方法是使用泛型，只接受实现answer中所述的

Comparable

接口的类型。在这种情况下，每个类都有适当的逻辑，可以按照设计人员的意图比较类的一个或多个方面。然后，所需的就是传递对象（在您的例子中是数组）到排序方法

class SomeClass {
    public int id;
    public SomeClass(int id) {
        this.id = id;
    }
    public String toString() {
        return id+"";
    }
}