如何在Java中將通用列表轉換為通用數組？

Question

我試圖編寫一個通用類來對任何類型的數組進行排序。
First sort函數可以對任何類型的數組進行排序。 它的工作正常。

在第二個排序函數中，我傳遞了列表，並嘗試轉換為數組以使用第一個排序函數。 但是，當我嘗試將列表轉換為通用類內部的數組時，會引發意外的類型錯誤。

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

此外，在將列表轉換為數組的方法中，您想在Comparable數組中分配一個Object數組。 但是您不能這樣做，因為所有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

問題是第二種sort方法中的<T extends Comparable> 。 類型T 遮蓋了您的類類型T

您可以重命名它，但是由於您沒有在第一種方法中返回任何內容，因此最快的解決方法是將其省略，以使編譯器再次感到滿意。 從您的代碼開始，這將轉換為以下內容：

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