Question

我有一个通用数组（它保持元素集和类型元素是通用的（可能是int，也许是char，也许是String等）。

而且我认为一个集合已经排序，所以我想使用bubblesort算法。但是我带了// bad operand types for binary operator '>'这条错误消息。

我可以为此sort函数做些什么来处理一些不同的数据类型（String，int，char，double）

这是我的代码：

void bubbleSort(T arr[]){
    int n = arr.length;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < n-i-1; j++){
             if (arr[j] > arr[j+1]){  // bad operand types for binary operator '>'              
                  T temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
             }
         }
    }
}

EDIT1：

如果我试过compareTo：

void bubbleSort(T arr[]){
    int n = arr.length;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < n-i-1; j++){
             if (arr[j].compareTo(arr[j+1])<0){  // bad operand types for binary operator '>'              
                  T temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
             }
         }
    }
}

错误消息是：

cannot find symbol
  symbol:   method compareTo(T)
  location: class Object
  where T is a type-variable:
    T extends Object declared in class MySet

Edit2：如果我试过这个：

<T extends Comparable<T>> void  bubbleSort(T arr[]) {
int n = arr.length;
for (int i = 0; i < n-1; i++){
    for (int j = 0; j < n-i-1; j++){
         if (arr[j].compareTo(arr[j+1])> 0) {
              T temp = arr[j];
              arr[j] = arr[j+1];
              arr[j+1] = temp;
         }
     }
}

}

调用函数bubbleSort时：

private T[] data;
bubbleSort(data);

错误消息是：

method bubbleSort in class Set<T#2> cannot be applied to given types;
  required: T#1[]
  found: T#2[]
  reason: inference variable T#1 has incompatible bounds
    upper bounds: Comparable<T#1>
    lower bounds: T#2
  where T#1,T#2 are type-variables:
    T#1 extends Comparable<T#1> declared in method <T#1>bubbleSort(T#1[])
    T#2 extends Object declared in class Set
----
(Alt-Enter shows hints)

EDIT3：

如果我试试这个：

void bubbleSort(Comparable arr[]) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < n-i-1; j++){
             if (arr[j].compareTo(arr[j+1])> 0) {
                  Comparable temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
             }
         }
    }
}

并调用函数bubbleSort：

   private T[] data;
    bubbleSort(data);

错误消息是：

incompatible types: T[] cannot be converted to Comparable[]
  where T is a type-variable:
    T extends Object declared in class MySet
----
(Alt-Enter shows hints)

Answer 1

你不能，除非你知道它们至少是Comparable。你不能在一个对象上使用不等式运算符，因为它们不能保证自动装帧到原始对象。

您的通用类型至少应为Comparable：

public class Sorter<T extends Comparable<T>> { }

...你应该研究compareTo，这是我为读者留下的一个练习。

Answer 2

您可以改为使用

arr[j].compareTo(arr[j+1]) > 0

但这需要T为Comparable，在这种情况下，函数签名应如下所示：

void bubbleSort(Comparable arr[])

Answer 3

答案简短 - 你做不到。为了能够对数组进行排序，您需要能够比较每两个元素，这对于每个类都是不可能的。

一种选择是将自己限制在Comparable：

<T extends Comparable<T>> void  bubbleSort(T arr[]) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < n-i-1; j++){
             if (arr[j].compareTo(arr[j+1])) > 0 {
                  T temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
             }
         }
    }
}

或者，您可以允许来电者提供他们自己的Comparator：

<T> void  bubbleSort(T arr[], Comparator<T> cmp) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < n-i-1; j++){
             if (cmp.compare(arr[j], arr[j+1])) > 0 {
                  T temp = arr[j];
                  arr[j] = arr[j+1];
                  arr[j+1] = temp;
             }
         }
    }
}

Answer 4

这是一种适用于泛型的插入排序。我是一个Java新手，但是我发誓我更改了用于测试通用类的对象中的.equals ，以正确地重载它工作的对象类。这是我的.equals：

public boolean equals(Object obj) {
        if (obj != null && getClass() == obj.getClass()) {
            Transaction q = (Transaction)obj;
            return getValue() == q.getValue() && getDate().equalsIgnoreCase(q.getDate()) && getProvider().equalsIgnoreCase(q.getProvider());
        }
        return false;
    }

查看this link以获得更简单的示例。

这是我的插入内容。我只是使用我现在正在做的实验室中的对象。

private void insertionSort(){

        T temp;
        for (int i = 1; i < numElements; i++) {
            for(int j = i ; j > 0 ; j--){
                if (((Comparable)list[j]).compareTo(list[j-1]) < 0) {
                    temp = list[j];
                    list[j] = list[j-1];
                    list[j-1] = temp;
                }
            }
        }

请原谅我对.equals想法的无知，但我只是想把它扔在那里。我进行了很多更改，并且可能感到困惑。

此外，如果有区别，我只是声明了类public class MyArrayUnsortedList<T>而不是public class MyArrayUnsortedList<T extends Comparable<T>>。

如何对通用数组进行排序？

4 个答案: