为什么我不能创建一个通用气泡排序与发电机？ （JAVA）

Question

我一直在努力学习泛型实现的排序类，但是我得到了这个错误：“无法对类型Comparator的非静态方法compare（T，T）进行静态引用”（第14行）

为什么我会收到此消息？我没有声明我的排序类是静态的。

我正在尝试创建一个可以用于任何类型的类的排序类，只要它实现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
            }
          }
        }



}

}

非常感谢！ （我知道这是一个新手问题，但我真的无法理解，需要理解这一点：）

Answer 1

T代表一个类，所以在行

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

你正在进行静态方法调用。

您可能需要更改

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

Answer 2

比较器在一个对象上工作而不是静态的 - 所以你应该从数组中获取两个值，在第一个上调用compare方法，并将第二个作为参数传递。

Answer 3

  

我正在尝试创建一个可以用于任何类型的类的排序类，只要它实现Comparator。

嗯，这是一条不寻常的道路。 Comparator通常是与正在排序的东西分开的类。

制作一个可用于任何类型类的排序类是明智的，只要它实现Comparable。

您还在构造函数中放置了大量的排序逻辑，这也有点不正常。制作一个单独的方法来完成工作通常会更好。

为Comparable接口执行此操作的合理方法大致如下：

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));
    }
}

或者，您可以合理地创建一个可用于任何类型的类的排序类，并为该类提供Comparator：

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));
    }
}

当然冒泡排序不是一个好的排序，并且Java库中已经有更好的排序，但这是一个很好的学习练习。

Answer 4

T.compare是一个静态参考。不能用那个。您需要将实例与另一个实例进行比较 另外，不比较只采用一个参数？