Question

我尝试编写一个泛型类来对任何类型的数组进行排序第一个排序函数对任何类型的数组进行排序。工作正常。

在第二个排序函数中，我传递了list并尝试转换为数组以使用第一个排序函数。但是当我试图将列表转换为泛型类中的数组时，它会抛出意外的类型错误。

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

    public class Sort<T extends Comparable>{
         //public T l;
         T tmp;
        public  void sort(T[] l){

        for(int i=0;i<l.length;i++){
           for(int j=i+1;j<l.length;j++){
              if(l[i].compareTo(l[j])>0){
                   tmp=l[i];
                  l[i]=l[j];
                   l[j]=tmp;
              }
            }
        }
                    System.out.println( Arrays.asList(l));
              }
         public  <T extends Comparable>  void sort(List<T> l){
          T[] array = (T[]) new Object[l.size()];
          sort(l.toArray(T[] array));
      // System.out.println(l);
         }   

    public static void main(String[] args){
                Integer[] i={2,4,1,5,3};
                List<String> l = Arrays.asList("c","d","a","e","b");
                Sort s=new Sort();
                //String[] j=l.toArray(new String[l.size()]);
                s.sort(i);
                s.sort(l);

            }
    }

Answer 1

因为你没有在类级别上暗示任何泛型参数（例如Sort(<)String(>) s = new Sort<>()）这意味着你无法将它与Integer arrray一起使用（反之亦然，如果你使用Integer作为泛型类型）。我要做的是在方法级别上使用泛型参数。（正如你对第二种方法所做的那样）

public class Sort {

    public  <T extends Comparable> void sort(T[] l){
    T tmp;
    for(int i=0;i<l.length;i++){
       for(int j=i+1;j<l.length;j++){
          if(l[i].compareTo(l[j])>0){
               tmp=l[i];
              l[i]=l[j];
               l[j]=tmp;
          }
        }
    }
                System.out.println( Arrays.asList(l));
          }
     public  <T extends Comparable>  void sort(List<T> l){
      T[] array = (T[]) new Object[l.size()];
      sort(l.toArray(T[] array));
  // System.out.println(l);
     }

Answer 2

正如n247s建议的那样，如果你想在它们之间保持一致，你应该为类和方法使用相同的参数化类型。
它提出了另一个问题：如果你这样做，你不应该混合橙子和香蕉，否则你的排序会产生意想不到的结果。假设您在数组或列表中放入了可比较对象的混合体，这些对象并非旨在在它们之间进行比较：String，Boolean，CustomClassWhichIsComparable

此外，在将列表转换为数组的方法中，您希望在Object数组中分配Comparable数组。但是你不能这样做，因为所有Object个实例都不一定是Comparable个实例。

 public  <T extends Comparable>  void sort(List<T> l){
   T[] array = (T[]) new Object[l.size()];
   sort(l.toArray(T[] array));
 }

你可以这样做：

public void sort(List<T> l) {
  T[] array = (T[]) new Comparable[l.size()];
  sort(l.toArray(array));
}

在这两种情况下，您都会收到警告但没有例外。

以下是提议修改的类：

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

    T tmp;


    public void sort(T[] l) {

    for (int i = 0; i < l.length; i++) {
        for (int j = i + 1; j < l.length; j++) {
          if (l[i].compareTo(l[j]) > 0) {
            tmp = l[i];
            l[i] = l[j];
            l[j] = tmp;
          }
        }
    }
      System.out.println(Arrays.asList(l));
    }

    public void sort(List<T> l) {
       T[] array = (T[]) new Comparable[l.size()];
       sort(l.toArray(array));
     }

    public static void main(String[] args) {
      Integer[] i = { 2, 4, 1, 5, 3 };
      Sort<Integer> sortInt = new Sort<Integer>();
      sortInt.sort(i);

      Sort<String> sortString = new Sort<String>();
      List<String> l = Arrays.asList("c", "d", "a", "e", "b");
      sortString.sort(l);
    }
}

Answer 3

问题在于您的第二个Factor [2] Factor [2] Factor [3] Sum [7]方法中的<T extends Comparable>。此类型sort shadowing 您的班级类型T。

您可以重命名它，但由于您没有在第一种方法中返回某些内容，因此最快的解决方法是将其保留，以便编译器再次开心。从您的代码开始，这将转换为以下内容：

如何将通用List转换为Java中的通用数组？

3 个答案: