how to convert a generic List to a generic array in Java?

Question

I tried to write a generic class to sort a array of any type.
First sort function does sorting of any type of array. Its working fine.

In second sort function, I passed list and tried to convert into array to use first sort function. But when i tried to convert list into array inside generic class, It throws unexpected type error.

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

            }
    }

davidxxx · Accepted Answer · 2016-12-04 09:50:48Z

As n247s suggested, you should use the same parameterized type for class and methods if you want to have a consistence between them.
It asks another question : if you do it, you should not mix oranges and bananas since otherwise your sort could give unexpected results. Suppose, you put in the array or in the List, a mix of Comparable objects which are not designed to be compared between them : String, Boolean, CustomClassWhichIsComparable

Besides, in your method which converts the list to an array, you want to assign a array of Object in a array of Comparable. But you cannot do it because all Object instances are not necessarily Comparable instances.

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

You could do it :

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

In both cases, you would have a warning but no exception.

Here is the class with proposed modifications :

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

n247s · Accepted Answer · 2016-12-04 10:13:17Z

Its because you didnt imply any generic arguments on class level (e.g. Sort(<)String(>) s = new Sort<>()) It means you wont be able to use it with the Integer arrray(and vice versa if you used Integer as generic type). What I would do is using the generic argument on method level instead. (As you did with the second method)

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

Nick Vanderhoven · Accepted Answer · 2016-12-04 08:19:22Z

0

The problem is the <T extends Comparable> in your second sort method. This type T is shadowing your class type T.

You could rename it, but since you don't return something in the first method, the quickest fix is to just leave it out, so that the compiler is happy again. Starting with your code, that would translate to something like this:

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

answered Dec 4, 2016 at 8:19

Nick Vanderhoven

3,09320 silver badges27 bronze badges

Collectives™ on Stack Overflow

how to convert a generic List to a generic array in Java?

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related