为什么不能使用generator创建通用的bubbleSort？ （JAVA）

Question

I've been trying to learn Generics implementation of a sorting class, but I get this error: "Cannot make a static reference to the non-static method compare(T, T) from the type Comparator" (line 14).

Why do I get this message? I haven't declared my sorting class static.

I'm trying to make a sorting class which could be used for any type of class as long as it implements Comparator.

public class GenericBSort<T extends Comparator<T>> {

public GenericBSort(T[] arr){
     boolean needNextPass = true;
        for (int k = 1; k < arr.length && needNextPass; k++)
        { // Array may be sorted and next pass not needed
          needNextPass = false;
          for (int i = 0; i < arr.length - k; i++){  
              if (T.compare(arr[i], arr[i + 1])>0){ // Swap list[i] with list[i + 1]
                  T temp = arr[i];
                  arr[i] = arr[i + 1];
                  arr[i + 1] = temp;

                  needNextPass = true; // Next pass still needed
            }
          }
        }



}

}

Thanks a lot! (I know it's a newbie question but I really couldn't figure it out and need to understand this : )

Answer 1

T represents a class, so in the line

if(T.compare(arr[i], arr[i + 1])>0)

you are doing a static method call.

You probably need to change it for

if(arr[i].compare(arr[i + 1])>0)

Answer 2

比较器对一个对象起作用，并且不是静态的-因此您应该从数组中获取两个值，在第一个上调用compare方法，然后将第二个作为参数传递。

Answer 3

I'm trying to make a sorting class which could be used for any type of class as long as it implements Comparator.

Well, that's an unusual path. Comparator normally is a separate class from the thing being sorted.

It's sensible to make a sorting class which could be used for any type of class as long as it implements Comparable .

You've also put much of the sorting logic in the constructor, which is a bit abnormal as well. It's usually better to make a separate method that does the work.

A reasonable approach to doing this for the Comparable interface would be approximately as follows:

public class ComparableSort<T extends Comparable<T>> {

    public ComparableSort() {
    }

    public void sort(T[] arr){
        boolean needNextPass = true;
        for (int k = 1; k < arr.length && needNextPass; k++)
        { // Array may be sorted and next pass not needed
            needNextPass = false;
            for (int i = 0; i < arr.length - k; i++){
                if (arr[i].compareTo(arr[i + 1])>0){ // Swap list[i] with list[i + 1]
                    T temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;

                    needNextPass = true; // Next pass still needed
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[] test = new Integer[]{5,3,2,4,1};
        ComparableSort<Integer> sorter = new ComparableSort<Integer>();
        sorter.sort(test);
        System.out.println(Arrays.toString(test));
    }
}

Alternatively, you can sensibly make a sorting class which can be used for any type of class at all with the provision of a Comparator for that class:

public class ComparatorSort<T> {

    private final Comparator<T> comp;

    public ComparatorSort(Comparator<T> comp){
        this.comp = comp;
    }

    public void sort(T[] arr){
        boolean needNextPass = true;
        for (int k = 1; k < arr.length && needNextPass; k++)
        { // Array may be sorted and next pass not needed
            needNextPass = false;
            for (int i = 0; i < arr.length - k; i++){
                if (comp.compare(arr[i], arr[i + 1])>0){ // Swap list[i] with list[i + 1]
                    T temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;

                    needNextPass = true; // Next pass still needed
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[] test = new Integer[]{5,3,2,4,1};
        ComparatorSort<Integer> sorter = new ComparatorSort<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer integer, Integer integer2) {
                if (integer > integer2)
                    return 1;
                else if (integer < integer2)
                    return -1;
                return 0;
            }
        });
        sorter.sort(test);
        System.out.println(Arrays.toString(test));
    }
}

Of course bubble sort isn't a good sort, and there are better sorts built into Java libraries already, but this is a good learning exercise.

Answer 4

T.compare is a static reference. Can't use that. You need to compare an instance with another instance.
Plus, doesn't compare take only a single argument?